\n\nAssistant:",
"temperature": float,
"top_p": float,
"top_k": int,
"max_tokens_to_sample": int,
"stop_sequences": [string]
}
```
Los siguientes parámetros son obligatorios.
+ **prompt**: (obligatorio) es la petición que desea que complete Claude. Para generar una respuesta adecuada, debe formatear la petición alternando los turnos conversacionales `\n\nHuman:` y `\n\nAssistant:`. Por ejemplo:
```
"\n\nHuman: {userQuestion}\n\nAssistant:"
```
Para obtener más información, consulte [Validación de prompts](https://docs.anthropic.com/claude/reference/prompt-validation) en la documentación de Anthropic Claude.
+ **max\$1tokens\$1to\$1sample**: (obligatorio) número máximo de tokens a generar antes de realizar paradas. Recomendamos un límite de 4000 tokens para un rendimiento óptimo.
Tenga en cuenta que es posible que los modelos Anthropic Claude dejen de generar tokens antes de alcanzar el valor de `max_tokens_to_sample`. Los distintos modelos de Anthropic Claude tienen valores máximos diferentes para este parámetro. Para obtener más información, consulte la [comparativa de modelos](https://docs.anthropic.com/claude/docs/models-overview#model-comparison) proporcionada en la documentación de Anthropic Claude.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
Los siguientes son parámetros opcionales.
+ **stop\$1sequence**: (opcional) secuencias que harán que el modelo deje de generar.
Los modelos de Anthropic Claude se detienen en `"\n\nHuman:"` y es posible que en el futuro incluyan secuencias de parada adicionales. Utilice el parámetro de inferencia `stop_sequences` para incluir cadenas adicionales que indiquen al modelo que deje de generar texto.
+ **temperature**: (opcional) la cantidad de asignación al azar que se inyecta en la respuesta. Utilice un valor más cercano a 0 para las tareas analíticas o de opción múltiple y un valor más cercano a 1 para las tareas creativas y generativas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1p**: (opcional) utilice el muestreo de núcleos.
En el muestreo de núcleos, Anthropic Claude calcula la distribución acumulada entre todas las opciones de cada token subsiguiente en orden de probabilidad decreciente y la corta cuando alcanza una probabilidad determinada especificada por `top_p`. Debe modificar `temperature` o `top_p`, pero no ambos.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1k**: (opcional) solo una muestra de las opciones K superior para cada token subsiguiente.
Use `top_k` para eliminar las respuestas de baja probabilidad de cola larga.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
------
#### [ Response ]
El modelo Anthropic Claude devuelve los siguientes campos para realizar una llamada de inferencia de Text Completion.
```
{
"completion": string,
"stop_reason": string,
"stop": string
}
```
+ **completion**: la finalización resultante hasta y excluyendo las secuencias de parada.
+ **stop\$1reason**: motivo por el que el modelo ha dejado de generar la respuesta.
+ **“stop\$1sequence”**: el modelo ha alcanzado una secuencia de parada, ya sea proporcionada por usted con el parámetro de inferencia `stop_sequences` o una secuencia de parada integrada en el modelo.
+ **“max\$1tokens”**: el modelo ha superado `max_tokens_to_sample` o el número máximo de tokens del modelo.
+ **stop**: si especifica el parámetro de inferencia de `stop_sequences`, `stop` contiene la secuencia de parada que ha indicado al modelo que deje de generar texto. Por ejemplo, `holes` en la siguiente respuesta.
```
{
"completion": " Here is a simple explanation of black ",
"stop_reason": "stop_sequence",
"stop": "holes"
}
```
Si no especifica `stop_sequences`, el valor de `stop` estará vacío.
------
## Ejemplo de código
En estos ejemplos se muestra cómo llamar al modelo *Anthropic Claude V2* con un rendimiento bajo demanda. Para usar la versión 2.1 de Anthropic Claude, cambie el valor de `modelId` a `anthropic.claude-v2:1`.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "\n\nHuman: explain black holes to 8th graders\n\nAssistant:",
"max_tokens_to_sample": 300,
"temperature": 0.1,
"top_p": 0.9,
})
modelId = 'anthropic.claude-v2'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completion'))
```
El siguiente ejemplo muestra cómo generar texto en streaming con Python utilizando la petición *escribir un ensayo para vivir en Marte de 1000 palabras* y el modelo Anthropic Claude V2:
```
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()))
```
# API de Messages de Anthropic Claude
En esta sección se proporcionan parámetros de inferencia y ejemplos de código para utilizar la API de Messages de los modelos Anthropic Claude.
**Topics**
+ [Descripción general de la API de Messages de Anthropic Claude](#model-parameters-anthropic-claude-messages-overview)
+ [Uso de herramienta](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Pensamiento extendido](claude-messages-extended-thinking.md)
+ [Pensamiento adaptativo](claude-messages-adaptive-thinking.md)
+ [Cifrado de pensamiento](claude-messages-thinking-encryption.md)
+ [Diferencias de la característica de pensamiento entre las versiones de los modelos](claude-messages-thinking-differences.md)
+ [Compactación](claude-messages-compaction.md)
+ [Obtenga resultados JSON validados de los modelos](claude-messages-structured-outputs.md)
+ [Solicitud y respuesta](model-parameters-anthropic-claude-messages-request-response.md)
+ [Ejemplos de código](api-inference-examples-claude-messages-code-examples.md)
+ [Modelos compatibles](claude-messages-supported-models.md)
## Descripción general de la API de Messages de Anthropic Claude
Puede usar la API de Messages para crear bots de chat o aplicaciones de asistente virtual. La API administra los intercambios conversacionales entre un usuario y un modelo de Anthropic Claude (asistente).
**nota**
En este tema se muestra cómo utilizar la API de Anthropic Claude mensajes con las operaciones de inferencia base ([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)). Sin embargo, le recomendamos que utilice la API Converse para implementar mensajes en su aplicación. La API Converse proporciona un conjunto unificado de parámetros que funcionan en todos los modelos que admiten mensajes. Para obtener más información, consulte [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md).
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.
Anthropic entrena los modelos de Claude para que funcionen en turnos de conversación alternos entre el usuario y el asistente. Al crear un mensaje nuevo, se especifican los turnos de conversación anteriores con el parámetro messages. A continuación, el modelo genera el siguiente mensaje de la conversación.
Cada mensaje de entrada debe ser un objeto con un rol y contenido. Puede especificar un único mensaje de rol de usuario o puede incluir varios mensajes de usuario y asistente.
Si utiliza la técnica de rellenar previamente la respuesta desde Claude (rellenando el principio de la respuesta de Claude con un mensaje final del rol de asistente), Claude responderá retomando la respuesta desde donde la dejó. Con esta técnica, Claude seguirá devolviendo una respuesta con el rol de asistente.
Si el mensaje final utiliza el rol de asistente, el contenido de la respuesta continuará inmediatamente con el contenido de ese mensaje. Puede usar esto para restringir parte de la respuesta del modelo.
Ejemplo con un solo mensaje de usuario:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Ejemplo con varios turnos de conversación:
```
[
{"role": "user", "content": "Hello there."},
{"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
{"role": "user", "content": "Can you explain LLMs in plain English?"},
]
```
Ejemplo con una respuesta parcialmente completa de Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
El contenido de cada mensaje de entrada puede ser una sola cadena o una matriz de bloques de contenido, donde cada bloque tiene un tipo específico. Una cadena es como la abreviatura de una matriz de un bloque de contenido del tipo “texto”. Los siguientes mensajes de entrada son equivalentes:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Para obtener información sobre cómo crear peticiones para modelos de Anthropic Claude, consulte [Descripción general de la ingeniería de prompts](https://docs.anthropic.com/claude/docs/intro-to-prompting) en la documentación de Anthropic Claude. Si ya tiene peticiones de [Text Completion](model-parameters-anthropic-claude-text-completion.md) que desea migrar a la API de Messages, consulte [Migrando desde Completaciones de Texto](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**importante**
El tiempo de espera para las llamadas de inferencia a los modelos Anthropic Claude 3.7 Sonnet y Claude 4 es de 60 minutos. De forma predeterminada, los clientes AWS del SDK se agotan después de 1 minuto. Le recomendamos que aumente el tiempo de espera de lectura de su cliente del AWS SDK a al menos 60 minutos. Por ejemplo, en el SDK botocore de Python de AWS , cambie el valor del campo `read_timeout` en [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) a, al menos, 3600.
### Peticiones del sistema
También puede incluir una petición del sistema en la solicitud. Una petición del sistema le permite proporcionar contexto e instrucciones a Anthropic Claude, por ejemplo, especificar un objetivo o rol en particular. Especifique una petición del sistema en el campo `system`, tal como se muestra en el siguiente ejemplo.
```
"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
harmless, and honest. Your goal is to provide informative and substantive responses
to queries while avoiding potential harms."
```
Para obtener más información, consulte [Prompt de sistema](https://docs.anthropic.com/en/docs/system-prompts) en la documentación de Anthropic.
### Peticiones multimodales
Una petición multimodal combina varias modalidades (imágenes y texto) en una sola petición. Las modalidades se especifican en el campo de entrada `content`. El siguiente ejemplo muestra cómo puede solicitar a Anthropic Claude una descripción del contenido de una imagen proporcionada. Para ver el código de ejemplo, consulte [Ejemplos de código multimodal](api-inference-examples-claude-messages-code-examples.md#api-inference-examples-claude-multimodal-code-example).
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw..."
}
},
{
"type": "text",
"text": "What's in these images?"
}
]
}
]
}
```
Cada imagen que incluya en una solicitud se tendrá en cuenta para el uso de tokens. Para obtener más información, consulte [Costos de imagen](https://docs.anthropic.com/claude/docs/vision#image-costs) en la documentación de Anthropic.
# Uso de herramienta
**aviso**
Como se indica, varias de las siguientes funciones se ofrecen en versión beta. Estas funciones están disponibles para usted como un «Servicio Beta», tal como se define en los Términos del AWS servicio. Está sujeto a su acuerdo con AWS él, a las condiciones del AWS servicio y al modelo de EULA aplicable.
Con los modelos Anthropic Claude, puede especificar una herramienta que el modelo puede usar para responder a un mensaje. Por ejemplo, puede especificar una herramienta que obtiene la canción más popular de una emisora de radio. Si el usuario pasa el mensaje *¿Cuál es la canción más popular en la emisora WZPZ?*, el modelo determina que la herramienta que usted ha especificado puede ayudar a responder la pregunta. En su respuesta, el modelo solicita que usted ejecute la herramienta en su nombre. A continuación, ejecuta la herramienta y pasa el resultado de la herramienta al modelo, que generará una respuesta para el mensaje original. Para obtener más información, consulte [Uso de herramientas (llamada a funciones)](https://docs.anthropic.com/en/docs/tool-use) en la documentación de Anthropic Claude.
**sugerencia**
Le recomendamos que utilice la API Converse para integrar el uso de la herramienta en la aplicación. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
**importante**
Claude Sonnet 4.5 ahora conserva el formato intencionado en los parámetros de las cadenas de llamada a herramientas. Anteriormente, las líneas nuevas al final de los parámetros de cadena a veces se eliminaban incorrectamente. Esta corrección garantiza que las herramientas que requieren un formato preciso (como los editores de texto) reciban los parámetros exactamente como está previsto. Se trata de una behind-the-scenes mejora que no requiere cambios en la API. Sin embargo, las herramientas con parámetros de cadena ahora pueden recibir valores con nuevas líneas finales que antes se eliminaban.
**nota**
Claude Sonnet 4.5 incluye optimizaciones automáticas para mejorar el rendimiento del modelo. Estas optimizaciones pueden añadir pequeñas cantidades de tokens a las solicitudes, pero no se le facturarán los tokens añadidos por el sistema.
Especifique las herramientas que quiere poner a disposición de un modelo en el campo `tools`. El siguiente ejemplo es de una herramienta que obtiene la canción más popular de una emisora de radio.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"input_schema": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
]
```
Cuando el modelo necesita una herramienta para generar una respuesta a un mensaje, devuelve información sobre la herramienta solicitada y la entrada en la herramienta en el campo `content` del mensaje. También establece el motivo de parada de la respuesta a `tool_use`.
```
{
"id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"stop_sequence": null,
"usage": {
"input_tokens": 375,
"output_tokens": 36
},
"content": [
{
"type": "tool_use",
"id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"name": "top_song",
"input": {
"sign": "WZPZ"
}
}
],
"stop_reason": "tool_use"
}
```
En su código, llame a la herramienta en nombre de la herramienta. A continuación, pase el resultado de la herramienta (`tool_result`) en un mensaje de usuario al modelo.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
En su respuesta, el modelo utiliza el resultado de la herramienta para generar una respuesta para el mensaje original.
```
{
"id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"content": [
{
"type": "text",
"text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
}
],
"stop_reason": "end_turn"
}
```
## Transmisión de herramientas detallada
La transmisión de herramientas detallada es una capacidad del modelo Anthropic Claude disponible con Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 y Claude Opus 4. Con la transmisión de herramientas detallada, los desarrolladores de Claude pueden transmitir los parámetros de uso de las herramientas sin necesidad de almacenar en búfer ni validar los objetos JSON, lo que reduce la latencia necesaria para empezar a recibir parámetros de gran tamaño.
**nota**
Al utilizar herramientas de transmisión detallada es posible que reciba entradas JSON parciales o no válidas. Asegúrese de tener en cuenta estos casos límites en su código.
Para utilizar esta característica, simplemente añada el encabezado `fine-grained-tool-streaming-2025-05-14` a una solicitud de uso de herramienta.
A continuación, se muestra un ejemplo de cómo especificar el encabezado de transmisión de herramienta detallada:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"anthropic_beta": ["fine-grained-tool-streaming-2025-05-14"],
"messages": [
{
"role": "user",
"content": "Can you write a long poem and make a file called poem.txt?"
}
],
"tools": [
{
"name": "make_file",
"description": "Write text to a file",
"input_schema": {
"type": "object",
"properties": {
"filename": {
"type": "string",
"description": "The filename to write text to"
},
"lines_of_text": {
"type": "array",
"description": "An array of lines of text to write to the file"
}
},
"required": [
"filename",
"lines_of_text"
]
}
}
]
}
```
En este ejemplo, la transmisión de herramienta detallada permite a Claude transmitir las líneas de un poema largo a la llamada de herramienta `make_file` sin necesidad de almacenarlo en búfer para validar si el parámetro `lines_of_text` es un JSON válido. Esto significa que puede ver el flujo de parámetros a medida que llega, sin tener que esperar a que todo el parámetro se almacene en búfer y se valide.
Con la transmisión de herramientas detallada, los fragmentos de uso de herramienta comienzan a transmitirse más rápido y, a menudo, son más largos y contienen menos saltos de palabras. Esto se debe a las diferencias en el comportamiento de fragmentación.
Por ejemplo, sin transmisión detallada (15 segundos de retraso):
```
Chunk 1: '{"'
Chunk 2: 'query": "Ty'
Chunk 3: 'peScri'
Chunk 4: 'pt 5.0 5.1 '
Chunk 5: '5.2 5'
Chunk 6: '.3'
Chunk 8: ' new f'
Chunk 9: 'eatur'
...
```
Con transmisión detallada (3 segundos de retraso):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**nota**
Como la transmisión detallada envía parámetros sin almacenamiento en búfer ni validación de JSON, no hay garantías de que el flujo resultante se complete en una cadena JSON válida. En concreto, si se alcanza el valor de `max_tokens` de motivo de la parada, el flujo puede terminar a la mitad de un parámetro y puede estar incompleto. Por lo general, tendrá que escribir una lógica específica para gestionar cuándo se alcanza `max_tokens`.
## Uso de computadora (Beta)
Uso del equipo es una capacidad del modelo Anthropic Claude (en versión beta) disponible únicamente con Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 y Claude Opus 4. Con Uso de computadora, Claude puede ayudarlo a automatizar tareas mediante acciones básicas de la GUI.
**aviso**
La función de uso del ordenador está a su disposición como un «Servicio beta», tal como se define en las Condiciones del AWS servicio. Está sujeto a su acuerdo con AWS él, a las condiciones del AWS servicio y al modelo de EULA aplicable. Tenga en cuenta que la API de Computer Use presenta riesgos únicos que son distintos de los de las características de la API estándar o de las interfaces de chat. Estos riesgos aumentan cuando se utiliza la API de Computer Use para interactuar con internet. Para minimizar los riesgos, considere tomar las siguientes precauciones:
Utilice la característica Uso de computadora en una máquina virtual o un contenedor específicos con privilegios mínimos para evitar ataques directos al sistema o accidentes.
Evitar dar a la API de Computer Use acceso a datos o cuentas confidenciales, para prevenir el robo de información.
Limitar el uso del ordenador y el acceso a APIs Internet a los dominios obligatorios para reducir la exposición a contenido malicioso.
Para garantizar una supervisión adecuada, asigne a una persona a las tareas delicadas (como la toma de decisiones que podría tener consecuencias significativas en el mundo real) y para cualquier cosa que requiera un consentimiento afirmativo (como aceptar cookies, ejecutar transacciones financieras o aceptar las condiciones del servicio).
Cualquier contenido que permita que Claude vea o acceda puede anular las instrucciones o provocar que Claude realice errores o acciones no deseadas. Es fundamental tomar las precauciones adecuadas, como aislar a Claude de las superficies sensibles, incluso para evitar los riesgos relacionados con una inyección de peticiones. Antes de habilitar o solicitar los permisos necesarios para activar las características Uso de computadora en sus propios productos, informe a los usuarios finales de los riesgos correspondientes y obtenga su consentimiento, según proceda.
La API de uso del equipo ofrece varias herramientas de uso del equipo predefinidas para su uso. A continuación, podrá crear una petición en la solicitud, como “envía un correo electrónico a Ben con las notas de mi última reunión” y una captura de pantalla (si es necesario). La respuesta contiene una lista de acciones de `tool_use` en formato JSON (por ejemplo, scroll\$1down, left\$1button\$1press, screenshot). El código ejecuta las acciones de la computadora y proporciona a Claude una captura de pantalla que muestra los resultados (cuando se solicita).
Desde la versión Claude 3.5 v2, el parámetro de herramientas se ha actualizado para que acepte tipos de herramientas polimórficas; se ha añadido una propiedad `tool.type` para distinguirlos. `type` es opcional; si se omite, se asume que se trata de una herramienta personalizada (anteriormente, era el único tipo de herramienta compatible). Para acceder al uso del equipo, debe usar el parámetro `anthropic_beta`, con la enumeración correspondiente, cuyo valor depende de la versión del modelo que se utilice. Para obtener más información, consulte la siguiente tabla.
Solo las solicitudes realizadas con este parámetro y enumeración pueden usar las herramientas de uso del equipo. Se puede especificar de la siguiente manera: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modelo | encabezado Beta |
| --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet | computer-use-2025-01-24 |
| Claude 3.5 Sonnet v2 | computer-use-2024-10-22 |
Para obtener más información, consulte [Uso de computadora (beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) en la documentación de Anthropic.
El siguiente es un ejemplo de respuesta donde se supone que la solicitud contiene una captura de pantalla de su escritorio con un icono de Firefox.
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"content": [
{
"type": "text",
"text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
},
{
"type": "tool_use",
"id": "toolu_123",
"name": "computer",
"input": {
"action": "mouse_move",
"coordinate": [
708,
736
]
}
},
{
"type": "tool_use",
"id": "toolu_234",
"name": "computer",
"input": {
"action": "left_click"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 3391,
"output_tokens": 132
}
}
```
## Herramientas definidas por Anthropic
Anthropic proporciona un conjunto de herramientas que permiten a determinados modelos Claude utilizar los equipos de forma eficaz. Al especificar una herramienta definida por Anthropic, los campos `description` y `tool_schema` no son necesarios ni están permitidos. Las herramientas definidas por Anthropic vienen definidas por Anthropic, pero debe evaluar explícitamente los resultados de la herramienta y devolver el elemento `tool_results` en Claude. Como ocurre con cualquier herramienta, el modelo no ejecuta automáticamente la herramienta. Cada herramienta definida por Anthropic tiene versiones optimizadas para modelos Claude 3.5 Sonnet (nuevos) y Claude 3.7 Sonnet específicos:
| Modelo | Herramienta | Notas |
| --- | --- | --- |
| ClaudeClaude Opus4.1 ClaudeClaude Opus4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 | {
"type": "text_editor_20250124",
"name": "str_replace_based_edit_tool"
} | Actualización a una herramienta de `str_replace_editor` existente |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Incluye nuevas acciones para un control más preciso |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Las mismas capacidades que la versión 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Las mismas capacidades que la versión 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "text_editor_20241022",
"name": "str_replace_editor"
} |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20241022",
"name": "bash"
} |
| Claude 3.5 Sonnet v2 | {
"type": "computer_20241022",
"name": "computer"
} |
El campo `type` identifica la herramienta y sus parámetros con fines de validación; el campo `name` es el nombre de la herramienta expuesto al modelo.
Si desea solicitar al modelo que utilice una de estas herramientas, puede hacer referencia explícita a la herramienta mediante el campo `name`. El campo `name` debe ser único en la lista de herramientas; no se puede definir una herramienta con el mismo `name` que una herramienta definida por Anthropic en la misma llamada a la API.
## Borrado automático de llamadas a herramientas (beta)
**aviso**
La compensación automática de llamadas a herramientas está disponible como un «servicio beta», tal como se define en las condiciones del AWS servicio.
**nota**
Actualmente, esta función es compatible con Claude Sonnet 4/4.5, Claude Haiku 4.5 y Claude Opus 4/4.1/4.5.
La eliminación automática de llamadas a herramientas es una función del modelo Anthropic Claude (en versión beta). Con esta función, Claude puede borrar automáticamente los resultados de uso de herramientas antiguas a medida que se acerque a los límites simbólicos, lo que permite una gestión del contexto más eficiente en escenarios de uso de herramientas de varios turnos. Para utilizar el borrado del uso de herramientas, debe añadir `context-management-2025-06-27` a la lista de encabezados beta del parámetro de solicitud anthropic\$1beta. También tendrá que especificar el uso de las siguientes opciones de configuración `clear_tool_uses_20250919` y elegir entre ellas.
Estos son los controles disponibles para la estrategia de administración del contexto de `clear_tool_uses_20250919`. Todos son opcionales o tienen valores predeterminados:
| **Opción de configuración** | **Descripción** |
| --- | --- |
| `trigger` predeterminado: 100 000 tokens de entrada | Define cuándo se activa la estrategia de edición de contexto. Una vez que la petición supere este umbral, empezará el borrado. Puede especificar este valor en input\$1tokens o tool\$1uses. |
| `keep` predeterminado: 3 usos de herramientas | Define el número de use/result pares de herramientas recientes que se van a conservar una vez se haya realizado el borrado. La API elimina primero las interacciones de herramientas más antiguas y conserva las más recientes. Resulta útil cuando el modelo necesita acceder a las interacciones recientes con las herramientas para continuar la conversación de forma eficaz. |
| `clear_at_least` (opcional) | Garantiza que se elimine un número mínimo de tokens cada vez que se active la estrategia. Si la API no puede eliminar al menos la cantidad especificada, la estrategia no se aplicará. Esto resulta útil para determinar si vale la pena interrumpir la caché de peticiones para borrar el contexto. |
| `exclude_tools` (opcional) | Lista de nombres de herramientas cuyos usos y resultados nunca deben borrarse. Útil para preservar un contexto importante. |
| `clear_tool_inputs` (opcional, valor predeterminado: false) | Controla si los parámetros de llamada a la herramienta se borran junto con los resultados de la herramienta. De forma predeterminada, solo se borran los resultados de la herramienta y se mantienen visibles las llamadas a herramienta originales de Claude, de modo que Claude pueda saber qué operaciones se han realizado incluso después de eliminar los resultados. |
**nota**
Al borrar las herramientas, se invalidará la memoria caché si los prefijos contienen las herramientas.
------
#### [ Request ]
```
response = client.beta.messages.create(
betas=["context-management-2025-06-27"],
model="claude-sonnet-4-20250514",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
extra_body={
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
# The below parameters are OPTIONAL:
# Trigger clearing when threshold is exceeded
"trigger": {
"type": "input_tokens",
"value": 30000
},
# Number of tool uses to keep after clearing
"keep": {
"type": "tool_uses",
"value": 3
},
# Optional: Clear at least this many tokens
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
# Exclude these tools uses from being cleared
"exclude_tools": ["web_search"]
}
]
}
}
)
```
------
#### [ Response ]
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_456",
"name": "data_analyzer",
"input": {
"data": "sample data"
}
}
],
"context_management": {
"applied_edits": [
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8, # Number of tool use/result pairs that were cleared
"cleared_input_tokens": 50000 # Total number of input tokens removed from the prompt
}
]
}
"stop_reason": "tool_use",
"usage": {
"input_tokens": 150,
"output_tokens": 50
}
}
```
------
#### [ Streaming Response ]
```
data: {"type": "message_start", "message": {"id": "msg_123", "type": "message", "role": "assistant"}}
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "tool_use", "id": "toolu_456", "name": "data_analyzer", "input": {}}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": "{\"data\": \"sample"}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": " data\"}"}}
data: {"type": "content_block_stop", "index": 0}
data: {"type": "message_delta", "delta": {"stop_reason": "tool_use"}}
data: {"type": "message_stop"}
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null,
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [...],
}
}
```
------
**nota**
Actualmente, Bedrock no admite la gestión `clear_tool_uses_20250919` del contexto en la CountTokens API.
## Herramienta de memoria (beta)
**aviso**
Memory Tool está disponible como un «servicio beta», tal como se define en las condiciones del AWS servicio.
Claude Sonnet 4.5 incluye una nueva herramienta de memoria que ofrece a los clientes una forma de administrar la memoria en las conversaciones. Con esta característica, los clientes pueden permitir que Claude recupere información fuera de la ventana contextual proporcionando acceso a un directorio local. Estará disponible como característica beta. Para utilizar esta característica, debe utilizar el encabezado beta `context-management-2025-06-27`.
Definición de herramienta:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Solicitud de ejemplo:
```
{
"max_tokens": 2048,
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["context-management-2025-06-27"],
"tools": [{
"type": "memory_20250818",
"name": "memory"
}],
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Remember that my favorite color is blue and I work at Amazon?"}]
}
]
}
```
Respuesta de ejemplo:
```
{
"id": "msg_vrtx_014mQ5ficCRB6PEa5k5sKqHd",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [
{
"type": "text",
"text": "I'll start by checking your memory directory and then record this important information about you."
},
{
"type": "tool_use",
"id": "toolu_vrtx_01EU1UrCDigyPMRntr3VYvUB",
"name": "memory",
"input": {
"command": "view",
"path": "/memories"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 1403,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 87
},
"context_management": {
"applied_edits": []
}
}
```
## Consideraciones relacionadas con el costo del uso de herramientas
Los precios de las solicitudes de uso de herramientas se basan en los siguientes factores:
1. Número total de tokens de entrada enviados al modelo (incluidos los del parámetro tools).
1. Número de tokens de salida generados.
El precio de las herramientas es el mismo que el de todas las demás solicitudes de la API Claude, pero incluyen tokens adicionales por solicitud. Los tokens adicionales derivados del uso de herramientas provienen de lo siguiente:
+ El parámetro `tools` en las solicitudes de la API. Por ejemplo, los nombres de herramientas, las descripciones y los esquemas.
+ Cualquier bloque de contenido `tool_use` en las solicitudes y respuestas de la API.
+ Cualquier bloque de contenido `tool_result` en las solicitudes de la API.
Cuando se utilizan herramientas, los modelos Anthropic incluyen automáticamente una petición de sistema especial que permite el uso de herramientas. El número de tokens de uso de herramientas necesarios para cada modelo se indica en la siguiente tabla. En esta tabla no se incluyen los tokens adicionales descritos anteriormente. Tenga en cuenta que en esta tabla se supone que se proporciona al menos una herramienta. Si no se proporciona ninguna herramienta, la opción de herramienta “none” utiliza 0 tokens de peticiones del sistema adicionales.
| Modelo | Selección de herramienta | Número de tokens de peticiones del sistema de uso de herramientas |
| --- | --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | auto o none | 346 |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | any o tool | 313 |
| Claude 3.5 Sonnet | auto o none | 294 |
| Claude 3.5 Sonnet | any o tool | 261 |
| Claude 3 Opus | auto o none | 530 |
| Claude 3 Opus | any o tool | 281 |
| Claude 3 Sonnet | auto o none | 159 |
| Claude 3 Sonnet | any o tool | 235 |
| Claude 3 Haiku | auto o none | 264 |
| Claude 3 Haiku | any o tool | 340 |
## Herramienta de búsqueda de herramientas (beta)
La herramienta de búsqueda de herramientas Claude permite trabajar con cientos o incluso miles de herramientas sin cargar todas sus definiciones por adelantado en la ventana de contexto. En lugar de declarar todas las herramientas de forma inmediata, puede marcarlas `defer_loading: true` y buscar Claude y cargar solo las herramientas que necesita mediante el mecanismo de búsqueda de herramientas.
Para acceder a esta función, debe utilizar el encabezado beta`tool-search-tool-2025-10-19`. Tenga en cuenta que, actualmente, esta función solo está disponible a través de [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Definición de herramienta:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Ejemplo de solicitud:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"tool-search-tool-2025-10-19"
],
"max_tokens": 4096,
"tools": [{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_files",
"description": "Search through files in the workspace",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string"
},
"file_types": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["query"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather in Seattle?"
}]
}
```
Ejemplo de respuesta
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with this task."
},
{
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex",
"input": {
"pattern": "weather"
}
},
{
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
},
{
"type": "text",
"text": "Now I can check the weather."
},
{
"type": "tool_use",
"id": "toolu_01XYZ789",
"name": "get_weather",
"input": {
"location": "Seattle",
"unit": "fahrenheit"
}
}
],
"stop_reason": "tool_use"
}
```
Ejemplo de streaming
```
# Event 1: content_block_start(with complete server_tool_use block) {
"type": "content_block_start",
"index": 0,
"content_block": {
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex"
}
}
# Event 2: content_block_delta(input JSON streamed) {
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "input_json_delta",
"partial_json": "{\"regex\": \".*weather.*\"}"
}
}
# Event 3: content_block_stop(tool_use complete) {
"type": "content_block_stop",
"index": 0
}
# Event 4: content_block_start(COMPLETE result in single chunk) {
"type": "content_block_start",
"index": 1,
"content_block": {
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}
}
# Event 5: content_block_stop(result complete) {
"type": "content_block_stop",
"index": 1
}
```
**Herramientas de búsqueda personalizadas**
Puede implementar herramientas de búsqueda de herramientas personalizadas (por ejemplo, mediante incrustaciones) definiendo una herramienta que devuelva bloques. `tool_reference` La herramienta personalizada debe tenerla, `defer_loading: false` mientras que otras herramientas deberían tenerla. `defer_loading: true` Cuando definas tu propia herramienta de búsqueda de herramientas, debería arrojar un resultado de la herramienta que contenga bloques de `tool_reference` contenido que apunten a las herramientas que deseas Claude usar.
El formato de respuesta de resultados de la herramienta de búsqueda de herramientas definido por el cliente esperado:
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
`tool_name`Debe coincidir con una herramienta definida en la solicitud. `defer_loading: true` Claude tendrá entonces acceso a los esquemas completos de esas herramientas.
**Herramientas de búsqueda personalizadas: ejemplo detallado**
Puede implementar herramientas de búsqueda de herramientas personalizadas (por ejemplo, mediante incrustaciones o búsquedas semánticas) definiendo una herramienta que devuelva bloques. `tool_reference` Esto permite mecanismos sofisticados de descubrimiento de herramientas que van más allá de la coincidencia de expresiones regulares.
Ejemplo de solicitud con un TST personalizado:
```
{
"model": "claude-sonnet-4-5-20250929",
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["tool-search-tool-2025-10-19"],
"max_tokens": 4096,
"tools": [{
"name": "semantic_tool_search",
"description": "Search for available tools using semantic similarity. Returns the most relevant tools for the given query.",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Natural language description of what kind of tool is needed"
},
"top_k": {
"type": "integer",
"description": "Number of tools to return (default: 5)"
}
},
"required": ["query"]
},
"defer_loading": false
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_flights",
"description": "Search for available flights between locations",
"input_schema": {
"type": "object",
"properties": {
"origin": {
"type": "string"
},
"destination": {
"type": "string"
},
"date": {
"type": "string"
}
},
"required": ["origin", "destination", "date"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather forecast in Seattle for the next 3 days?"
}]
}
```
Claudesu respuesta (llamando a un TST personalizado):
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with weather information."
},
{
"type": "tool_use",
"id": "toolu_01ABC123",
"name": "semantic_tool_search",
"input": {
"query": "weather forecast multiple days",
"top_k": 3
}
}
],
"stop_reason": "tool_use"
}
```
**Resultado de la herramienta proporcionada por el cliente**
Tras realizar una búsqueda semántica en la biblioteca de herramientas, el cliente devuelve las referencias de herramientas coincidentes:
```
{
"role": "user",
"content": [{
"type": "tool_search_tool_result",
"tool_use_id": "toolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}]
}
```
Claudesu seguimiento (mediante la herramienta descubierta)
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I found the forecast tool. Let me get the weather forecast for Seattle."
},
{
"type": "tool_use",
"id": "toolu_01DEF456",
"name": "get_weather",
"input": {
"location": "Seattle, WA"
}
}
],
"stop_reason": "tool_use"
}
```
**Gestión de errores**
+ La configuración `defer_loading: true` de todas las herramientas (incluida la herramienta de búsqueda de herramientas) arrojará un error 400.
+ Si se pasa una `tool_reference` sin la definición de herramienta correspondiente, se generará un error de 400
## Ejemplos de uso de herramientas (beta)
Claude OpusLa versión 4.5 admite ejemplos proporcionados por los usuarios en las definiciones de herramientas para aumentar el rendimiento Claude de uso de las herramientas. Puede proporcionar ejemplos como llamadas a funciones completas, formateadas exactamente como lo estarían las salidas LLM reales, sin necesidad de traducirlos a otro formato. Para utilizar esta función, debe pasar el encabezado beta. `tool-examples-2025-10-29`
Ejemplo de definición de herramienta:
```
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
},
"input_examples": [{
"location": "San Francisco, CA",
"unit": "fahrenheit"
},
{
"location": "Tokyo, Japan",
"unit": "celsius"
},
{
"location": "New York, NY"
}
]
}
```
**Reglas de validación**
+ Conformidad con el esquema: cada ejemplo `input_examples` debe ser válido según la `input_schema` herramienta.
+ Los campos obligatorios deben estar presentes en al menos un ejemplo.
+ Los tipos de campo deben coincidir con el esquema.
+ Los valores de enumeración deben ser del conjunto permitido.
+ Si la validación falla, devuelve un error 400 con detalles sobre qué ejemplo falló en la validación.
+ Requisitos de la matriz: `input_examples` debe ser una matriz (puede estar vacía).
+ `[]`La matriz vacía es válida y equivale a omitir el campo.
+ Un solo ejemplo debe seguir incluido en una matriz: `[{...}]`
+ Límite de longitud: comience con un límite de 20 ejemplos por definición de herramienta.
Ejemplos de errores:
```
// Invalid: Example doesn't match schema (missing required field)
{
"type": "invalid_request_error",
"message": "Tool 'get_weather' input_examples[0] is invalid: Missing required property 'location'"
}
// Invalid: Example has wrong type for field
{
"type": "invalid_request_error",
"message": "Tool 'search_products' input_examples[1] is invalid: Property 'filters.price_range.min' must be a number, got string"
}
// Invalid: input_examples on server-side tool
{
"type": "invalid_request_error",
"message": "input_examples is not supported for server-side tool"
}
```
# Pensamiento extendido
El pensamiento extendido proporciona Claude una mayor capacidad de razonamiento para tareas complejas, al tiempo que proporciona diferentes niveles de transparencia en su proceso de step-by-step pensamiento antes de dar su respuesta final. Siempre que active el modo de pensamiento de Claude, tendrá que establecer un presupuesto para el número máximo de tokens que Claude podrá utilizar en su proceso de razonamiento interno.
Los modelos admitidos son los siguientes:
| Modelo | ID del modelo |
| --- | --- |
| Claude Opus4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
| Claude Opus 4 | `anthropic.claude-opus-4-20250514-v1:0` |
| Claude Sonnet 4 | `anthropic.claude-sonnet-4-20250514-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` |
| Claude 3.7 Sonnet | `anthropic.claude-3-7-sonnet-20250219-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
**nota**
El comportamiento de la API difiere entre los modelos Claude 3.7 y Claude 4. Para obtener más información, consulte [Diferencias de la característica de pensamiento entre las versiones de los modelos](claude-messages-thinking-differences.md).
**Topics**
+ [Prácticas recomendadas y consideraciones de pensamiento extendido](#claude-messages-extended-thinking-bps)
+ [Cómo funciona el pensamiento extendido](#claude-messages-how-extended-thinking-works)
+ [Cómo utilizar el pensamiento extendido](#claude-messages-use-extended-thinking)
+ [Pensamiento extendido con el uso de herramientas](#claude-messages-extended-thinking-tool-use)
+ [Thinking Block Clearing (beta)](#claude-messages-thinking-block-clearing)
+ [Pensamiento extendido con almacenamiento en caché de peticiones](#claude-messages-extended-thinking-prompt-caching)
+ [Comportamiento del almacenamiento en caché de los bloques de pensamiento](#claude-messages-extended-thinking-caching-behavior)
+ [Máximo de tokens y tamaño de la ventana de contexto con el pensamiento extendido](#claude-messages-extended-thinking-max-tokens)
+ [Consideraciones sobre el costo de los tokens de pensamiento extendido](#claude-messages-extended-thinking-cost)
## Prácticas recomendadas y consideraciones de pensamiento extendido
Directrices de uso
+ **Selección de tareas**: utilice el pensamiento extendido para tareas particularmente complejas que se benefician del step-by-step razonamiento, como las matemáticas, la codificación y el análisis.
+ **Manejo del contexto**: no es necesario que elimine usted mismo los bloques de pensamiento anteriores. La API de Anthropic omite automáticamente los bloques de pensamiento de los turnos anteriores y no se incluyen al calcular el uso del contexto.
+ **Ingeniería de peticiones**: si quiere maximizar las capacidades de pensamiento de Claude, consulte los [consejos de creación de peticiones de pensamiento extendido](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) de Anthropic.
Consideraciones sobre el rendimiento
+ **Tiempos de respuesta**: prepárese para tiempos de respuesta potencialmente más largos debido al procesamiento adicional que requiere el proceso de razonamiento. Tenga en cuenta que la generación de bloques de pensamiento podría aumentar el tiempo de respuesta total.
+ **Requisitos de transmisión**: la transmisión es obligatoria cuando `max_tokens` es superior a 21 333. Durante la transmisión, prepárese para gestionar los bloques de contenido `thinking` y `text` a medida que vayan llegando.
Compatibilidad de características
+ La característica de pensamiento no es compatible con las modificaciones de `temperature`, `top_p` o `top_k` ni con el [uso forzado de herramientas](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ No se pueden rellenar previamente las respuestas cuando la característica de pensamiento está habilitada.
+ Los cambios en el presupuesto de la característica de pensamiento invalidan los prefijos de las peticiones almacenados en caché que incluyen mensajes. Sin embargo, las peticiones del sistema y las definiciones de herramientas almacenadas en caché seguirán funcionando cuando cambien los parámetros de la característica de pensamiento.
Uso de presupuestos para la característica de pensamiento
+ **Optimizaciones del presupuesto**: el presupuesto mínimo es de 1024 tokens. Anthropic sugiere empezar con el mínimo y aumentar el presupuesto de la característica de pensamiento de forma gradual para encontrar el intervalo óptimo para su caso de uso. Un mayor número de tokens puede permitir un razonamiento más completo y matizado, pero también puede provocar un rendimiento decreciente en función de la tarea. El presupuesto de la característica de pensamiento es un objetivo y no un límite estricto; el uso real de tokens puede variar en función de la tarea.
+ **Configuración mínima y óptima**: el presupuesto mínimo es de 1024 tokens. Le sugerimos empezar con el mínimo y aumentar el presupuesto de la característica de pensamiento de forma gradual para encontrar el intervalo óptimo que permita un buen rendimiento de Claude para su caso de uso. Un mayor número de tokens puede permitir un razonamiento más completo y matizado, pero también puede provocar un rendimiento decreciente de la tarea. El presupuesto de la característica de pensamiento es un objetivo y no un límite estricto; el uso real de tokens puede variar en función de la tarea.
+ **Experimentación**: el modelo podría funcionar de manera diferente con diferentes configuraciones de presupuesto de la característica de pensamiento. Aumentar el presupuesto máximo de la característica de pensamiento puede hacer que el modelo piense mejor o más, pero a cambio de una mayor latencia. Para las tareas críticas, considere la posibilidad de probar diferentes configuraciones de presupuesto para encontrar el equilibrio óptimo entre calidad y rendimiento.
+ **Presupuestos elevados**: para los presupuestos de la característica de pensamiento superiores a 32 000, le recomendamos que utilice el procesamiento por lotes para evitar problemas de red. Las solicitudes que llevan al modelo a procesar más de 32 000 tokens provocan solicitudes de larga duración, lo que puede causar tiempos de espera del sistema y superar los límites de conexiones abiertas. Tenga en cuenta que los límites de `max_tokens` varían según el modelo de Claude. Para obtener más información, consulte [Máximo de tokens y tamaño de la ventana de contexto con el pensamiento extendido](#claude-messages-extended-thinking-max-tokens).
+ **Seguimiento del uso de tokens**: supervise el uso de tokens de la característica de pensamiento para optimizar los costos y el rendimiento.
## Cómo funciona el pensamiento extendido
Cuando se activa el pensamiento extendido, Claude crea bloques de contenido `thinking` en los que genera su razonamiento interno. Claude incorpora la información de este razonamiento antes de elaborar una respuesta final. La respuesta de la API incluirá bloques de contenido `thinking`, seguidos de bloques de contenido `text`.
A continuación, se muestra un ejemplo del formato de respuesta predeterminado:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Para obtener más información sobre el formato de respuesta del pensamiento extendido, consulte [Solicitud y respuesta](model-parameters-anthropic-claude-messages-request-response.md) de la API Messages de Anthropic.
## Cómo utilizar el pensamiento extendido
Para activar el pensamiento extendido, añada un objeto `thinking`, con el parámetro `thinking` establecido en activado y `budget_tokens` establecido en un presupuesto de tokens para el pensamiento extendido.
El parámetro `budget_tokens` determina el número máximo de tokens que Claude puede utilizar para su proceso de razonamiento interno. En los modelos Claude 4, este límite se aplica a los tokens de pensamiento completo y no a la salida resumida. Los presupuestos más grandes pueden mejorar la calidad de la respuesta al permitir un análisis más exhaustivo de los problemas complejos, aunque es posible que Claude no utilice todo el presupuesto asignado, especialmente en intervalos superiores a 32 000.
El valor de `budget_tokens` debe estar establecido en un valor inferior a `max_tokens`. Sin embargo, si utiliza [Pensamiento intercalado (beta)](#claude-messages-extended-thinking-tool-use-interleaved) con herramientas, puede superar este límite, ya que el límite de tokens pasa a ser toda la ventana de contexto (200 000 tokens).
### Pensamiento resumido
Al habilitar el pensamiento extendido, la API Messages para modelos Claude 4 muestra un resumen del proceso de pensamiento completo de Claude. El pensamiento resumido proporciona todos los beneficios de inteligencia del pensamiento extendido, además de impedir su uso indebido.
Estas son algunas consideraciones importantes para el pensamiento resumido:
+ Se le cobrará por la totalidad de tokens de pensamiento generados por la solicitud original, no por los tokens de resumen.
+ El recuento de tokens de salida facturado no coincidirá con el recuento de tokens que aparece en la respuesta.
+ La petición proporcionada al modelo de resumidor está sujeta a cambios.
+ Las primeras líneas de la salida de pensamiento son más detalladas y proporcionan un razonamiento detallado que es particularmente útil para la ingeniería de peticiones.
**nota**
Claude 3.7 Sonnet devuelve igualmente la salida de pensamiento completa.
Para acceder a la salida de pensamiento completa para modelos Claude 4, póngase en contacto con el equipo de su cuenta.
### Transmisión de pensamiento
Puede transmitir las respuestas de pensamiento extendido mediante eventos enviados por el servidor (SSE). Cuando la transmisión está habilitada para el pensamiento extendido, recibe el contenido de pensamiento a través de eventos `thinking_delta`. Los eventos transmitidos no garantizan una frecuencia de retorno constante. Puede haber retrasos entre la transmisión de los eventos. Para obtener más documentación sobre la transmisión a través de la API Messages, consulte [Transmisión de mensajes](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
A continuación, te explicamos cómo gestionar la transmisión con el pensamiento mediante **InvokeModelWithResponseStream**:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Respuesta:
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
**Acerca del comportamiento de la transmisión con la característica de pensamiento**
Si utilizas el streaming con la función de pensar habilitada, te darás cuenta de que, a veces, el texto llega en trozos más grandes y se alternan con fragmentos más pequeños token-by-token. Este es el comportamiento esperado, especialmente para el contenido de pensamiento. El sistema de transmisión necesita procesar el contenido en lotes para obtener un rendimiento óptimo, lo que puede dar lugar a este patrón de entrega.
## Pensamiento extendido con el uso de herramientas
El pensamiento extendido se puede utilizar junto con [Uso de herramienta](model-parameters-anthropic-claude-messages-tool-use.md) para que Claude pueda razonar a través de la selección de herramientas y el procesamiento de resultados. Cuando utilice el pensamiento extendido junto con el uso de herramientas, tenga en cuenta las siguientes limitaciones:
+ **Limitación de la selección de herramientas**: el uso de herramientas con la característica de pensamiento solo admite `tool_choice: any`. No admite proporcionar una herramienta específica, `auto` ni ningún otro valor.
+ **Preservar los bloques de pensamiento**: durante el uso de la herramienta, debe pasar los bloques de pensamiento de vuelta a la API para el último mensaje del asistente. Incluya el bloque completo sin modificar de nuevo en la API para mantener la continuidad del razonamiento.
Así es como funciona la administración de la ventana de contexto con las herramientas:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
}
]
}
```
La primera respuesta es la siguiente:
```
{
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`...",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
},
{
"type": "text",
"text": "I can help you get the current weather information for Paris. Let me check that for you"
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
}
```
Continuar la conversación con el uso de herramientas generará otra respuesta. Observe que se pasa tanto `thinking_block` como `tool_use_block`. Si no se pasa, se produce un error.
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`…",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxY",
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"content": "Current temperature: 88°F"
}
]
}
]
}
```
La respuesta de la API ahora solo incluirá texto
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Conservación de los bloques de pensamiento
Durante el uso de herramientas, debe volver a pasar los bloques de pensamiento a la API y volver a incluir el bloque completo sin modificar en la API. Esto es fundamental para mantener el flujo de razonamiento y la integridad de la conversación del modelo.
**sugerencia**
Aunque puede omitir los bloques `thinking` de turnos anteriores del rol `assistant`, sugerimos enviar siempre todos los bloques de pensamiento de vuelta a la API en cualquier conversación que tenga lugar durante varios turnos. La API hará lo siguiente:
Filtra automáticamente los bloques de pensamiento proporcionados.
Utiliza los bloques de pensamiento pertinentes necesarios para preservar el razonamiento del modelo.
Solo se facturan los tokens de entrada de los bloques mostrados a Claude.
Cuando Claude invoca herramientas, pausa la creación de una respuesta para esperar información externa. Cuando se devuelvan los resultados de la herramienta, Claude seguirá creando la respuesta existente. Esto requiere conservar los bloques de pensamiento durante el uso de la herramienta, por las siguientes razones:
+ **Continuidad del razonamiento**: los bloques de pensamiento capturan Claude el step-by-step razonamiento que dio lugar a la solicitud de herramientas. Cuando se publican los resultados de la herramienta, la inclusión del pensamiento original garantiza que Claude pueda continuar con su razonamiento desde donde lo dejó.
+ **Mantenimiento del contexto**: aunque los resultados de la herramienta aparecen como mensajes de usuario en la estructura de la API, forman parte de un flujo de razonamiento continuo. Preservar los bloques de pensamiento mantiene este flujo conceptual en varias llamadas a la API.
**importante**
Al proporcionar bloques de pensamiento, toda la secuencia de bloques de pensamiento consecutivos debe coincidir con las salidas generadas por el modelo durante la solicitud original; no se puede reorganizar ni modificar la secuencia de estos bloques.
### Pensamiento intercalado (beta)
**aviso**
Interleaved Thinking está disponible como un «servicio beta», tal y como se define en las condiciones del servicio. AWS Está sujeto a su acuerdo con él, a las condiciones del AWS servicio AWS y al modelo de EULA aplicable.
Los modelos Claude 4 admiten el pensamiento intercalado, una característica que permite a Claude pensar entre las llamadas a herramientas y ejecutar un razonamiento más sofisticado después de recibir los resultados de la herramienta. Esto permite interacciones entre agentes más complejas, en las que Claude puede hacer lo siguiente:
+ Razonar sobre los resultados de una llamada a herramientas antes de decidir qué hacer a continuación
+ Encadenar varias llamadas a herramientas con pasos de razonamiento intermedios
+ Tomar decisiones más matizadas en función de los resultados intermedios
Para permitir el pensamiento intercalado, añada el encabezado beta `interleaved-thinking-2025-05-14` a su solicitud de API.
**nota**
Con el pensamiento intercalado, `budget_tokens` puede superar el parámetro `max_tokens`, ya que representa el presupuesto total de todos los bloques de pensamiento dentro de un turno de asistente.
## Thinking Block Clearing (beta)
**aviso**
Thinking Block Clearing está disponible como un «Servicio Beta», tal y como se define en las Condiciones del AWS Servicio.
**nota**
Actualmente, esta función es compatible con Claude Sonnet 4/4.5, Claude Haiku 4.5 y Claude Opus 4/4.1/4.5.
Pensar en la limpieza de bloques es una función del modelo Anthropic Claude (en versión beta). Con esta función, Claude puede eliminar automáticamente los bloques de pensamiento más antiguos de los turnos anteriores. Para usar Thinking block clear, debes añadirlos `context-management-2025-06-27` a la lista de encabezados beta del parámetro de solicitud anthropic\$1beta. También tendrás que especificar el uso de las siguientes opciones de configuración `clear_thinking_20251015` y elegir entre ellas.
Estos son los controles disponibles para la estrategia de administración del contexto de `clear_thinking_20251015`. Todos son opcionales o tienen valores predeterminados:
| **Opción de configuración** | **Descripción** |
| --- | --- |
| `keep` predeterminado: 1 turno de reflexión | Define cuántos turnos de asistente recientes con bloques de pensamiento desea conservar. Utilízalo `{"type": "thinking_turns", "value": N}` donde N debe estar > 0 para conservar los últimos N turnos o `{"type": "all"}` para conservar todos los bloques de pensamiento. |
------
#### [ Request ]
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"anthropic_beta": [
"context-management-2025-06-27"
],
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user is asking for the weather in Paris. I have access to a get_weather function that takes a location as a parameter. I have all the information I need to make this call - the location is \"Paris\".\n\nLet me call the get_weather function with \"Paris\" as the location.",
"signature": "ErgDCkgIChABGAIqQC/Ccv8GC+5VfcMEiq78XmpU2Ef2cT+96pHKMedKcRNuPz1x0kFlo5HBpW0r1NcQFVQUPuj6PDmP7jdHY7GsrUwSDKNBMogjaM7wYkwfPhoMswjlmfF09JLjZfFlIjB03NkghGOxLbr3VCQHIY0lMaV9UBvt7ZwTpJKzlz+mulBysfvAmDfcnvdJ/6CZre4qnQJsTZaiXdEgASwPIc5jOExBguerrtYSWVC/oPjSi7KZM8PfhP/SPXupyLi8hwYxeqomqkeG7AQhD+3487ecerZJcpJSOSsf0I1OaMpmQEE/b7ehnvTV/A4nLhxIjP4msyIBW+dVwHNFRFlpJLBHUJvN99b4run6YmqBSf4y9TyNMfOr+FtfxedGE0HfJMBd4FHXmUFyW5y91jAHMWqwNxDgacaKkFCAMaqce5rm0ShOxXn1uwDUAS3jeRP26Pynihq8fw5DQwlqOpo7vvXtqb5jjiCmqfOe6un5xeIdhhbzWddhEk1Vmtg7I817pM4MZjVaeQN02drPs8QgDxihnP6ZooGhd6FCBP2X3Ymdlj5zMlbVHxmSkA4wcNtg4IAYAQ=="
},
{
"type": "tool_use",
"id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"content": "Current temperature: 88°F"
}
]
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 1
}
}
]
}
}
```
------
#### [ Response ]
```
{
"model": "claude-haiku-4-5-20251001",
"id": "msg_bdrk_01KyTbyFbdG2kzPwWMJY1kum",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "The current weather in Paris is **88°F** (approximately 31°C). It's quite warm! If you need more detailed information like humidity, wind conditions, or a forecast, please let me know."
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 736,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"cache_creation": {
"ephemeral_5m_input_tokens": 0,
"ephemeral_1h_input_tokens": 0
},
"output_tokens": 47
},
"context_management": {
"applied_edits": [...]
}
}
```
------
## Pensamiento extendido con almacenamiento en caché de peticiones
El [almacenamiento en caché de peticiones](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) con la característica de pensamiento tiene varias consideraciones importantes:
**Eliminación del contexto de los bloques de pensamiento**
+ Los bloques de pensamiento de los turnos anteriores se eliminan del contexto, lo que puede afectar a los puntos de interrupción de la caché.
+ Al continuar las conversaciones con el uso de herramientas, los bloques de pensamiento se almacenan en caché y se contabilizan como tokens de entrada cuando se leen desde la memoria caché. Esto implica encontrar un equilibrio: aunque los bloques de pensamiento no ocupan espacio visual en la ventana de contexto, sí se contabilizan como tokens de entrada cuando se almacenan en caché.
+ Si la característica de pensamiento se desactiva, las solicitudes producirán un error si se pasa el contenido de pensamiento en el turno de uso de herramientas actual. En otros contextos, el contenido de pensamiento que se pasa a la API simplemente se ignora.
**Patrones de invalidación de caché**
+ Los cambios en los parámetros de pensamiento (como habilitar, deshabilitar o modificar la asignación de presupuesto) invalidan los puntos de interrupción de la memoria caché de los mensajes.
+ [Pensamiento intercalado (beta)](#claude-messages-extended-thinking-tool-use-interleaved) amplifica la invalidación de la memoria caché, ya que los bloques de pensamiento se pueden producir entre varias llamadas a una herramienta.
+ Las peticiones del sistema y las herramientas permanecen en caché aunque cambien los parámetros de pensamiento o se eliminen bloques.
**nota**
Aunque los bloques de pensamiento se eliminan para el almacenamiento en caché y los cálculos de contexto, deben preservarse al continuar las conversaciones con el uso de herramientas, especialmente cuando se utiliza el pensamiento intercalado.
## Comportamiento del almacenamiento en caché de los bloques de pensamiento
Cuando se utiliza el pensamiento extendido con el uso de herramientas, los bloques de pensamiento muestran un comportamiento de almacenamiento en caché específico que afecta al recuento de tokens. En la siguiente secuencia se muestra cómo funciona.
1. El almacenamiento en caché solo se produce cuando se realiza una solicitud posterior que incluye los resultados de la herramienta.
1. Cuando se realiza la siguiente solicitud, se puede almacenar en caché el historial de la conversación anterior (incluidos los bloques de pensamiento).
1. Estos bloques de pensamiento almacenados en caché se contabilizan como tokens de entrada en sus métricas de uso cuando se leen de la caché.
1. Cuando se incluye un bloque de non-tool-result usuario, todos los bloques de pensamiento anteriores se ignoran y se eliminan del contexto.
A continuación, se muestra un flujo de ejemplo detallado:
Solicitud 1:
```
User: "What's the weather in Paris?"
```
Respuesta 1:
```
[thinking_block 1] + [tool_use block 1]
```
Solicitud 2:
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Respuesta 2:
```
[thinking_block 2] + [text block 2]
```
La solicitud 2 escribe en una caché el contenido de la solicitud (no la respuesta). La caché incluye el mensaje original del usuario, el primer bloque de pensamiento, el bloque de uso de herramientas y el resultado de la herramienta.
Solicitud 3:
```
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
```
Como se incluyó un bloque de non-tool-result usuario, se ignoran todos los bloques de pensamiento anteriores. Esta solicitud se procesará de la misma manera que la siguiente:
Alternativa a la solicitud 3:
```
User: ["What's the weather in Paris?"]
Assistant: [tool_use block 1]
User: [tool_result_1, cache=True]
Assistant: [text block 2]
User: [Text response, cache=True]
```
Este comportamiento es constante tanto si se utiliza el pensamiento normal como el pensamiento intercalado.
## Máximo de tokens y tamaño de la ventana de contexto con el pensamiento extendido
En los modelos Claude más antiguos (anteriores a Claude 3.7 Sonnet), si la suma de los tokens de peticiones y max\$1tokens superaba la ventana de contexto del modelo, el sistema ajustaba automáticamente el valor de max\$1tokens de acuerdo con el límite del contexto. Esto significaba que se podía establecer un valor máximo de max\$1tokens y que el sistema lo reducía silenciosamente según fuera necesario. Con los modelos Claude 3.7 y 4 `max_tokens` (que incluye el presupuesto de la característica de pensamiento cuando esta característica está habilitada) impone un límite estricto. El sistema ahora devuelve un error de validación si los tokens de peticiones y max\$1tokens superan el tamaño de la ventana de contexto.
### La ventana de contexto con pensamiento extendido
Al calcular el uso de la ventana de contexto con la característica de pensamiento activada, hay que tener en cuenta algunas consideraciones:
+ Los bloques de pensamiento de los turnos anteriores se eliminan y no se contabilizan para la ventana de contexto.
+ El pensamiento del turno actual se contabiliza para el límite de `max_tokens` de ese turno.
La ventana de contexto efectiva se calcula de la siguiente manera: ventana de contexto = (tokens de entrada actuales, tokens de pensamiento anteriores) \$1 (tokens de pensamiento \$1 tokens de pensamiento cifrados \$1 tokens de salida de texto).
### Administración de los tokens con pensamiento extendido y uso de herramientas
Cuando se utiliza el pensamiento extendido con el uso de herramientas, los bloques de pensamiento deben conservarse de forma explícita y devolverse junto con los resultados de la herramienta. El cálculo efectivo de la ventana de contexto para el pensamiento extendido con el uso de herramientas es el siguiente:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Administración de los tokens con pensamiento extendido
Dada la ventana de contexto y el comportamiento de `max_tokens` con los modelos de pensamiento extendido Claude 3.7 y 4, es posible que tenga que realizar una de las siguientes acciones:
+ Supervise y administre el uso de tokens de forma más activa.
+ Ajuste los valores de `max_tokens` a medida que cambia la longitud de la peticiones.
+ Tenga en cuenta que los bloques de pensamiento anteriores no se acumulan en su ventana de contexto. Este cambio se ha realizado para proporcionar un comportamiento más predecible y transparente, especialmente dado que los límites máximos de tokens han aumentado considerablemente.
## Consideraciones sobre el costo de los tokens de pensamiento extendido
El proceso de pensamiento conlleva cargos por lo siguiente:
+ Tokens que se utilizan durante el pensamiento (tokens de salida)
+ Los bloques de pensamiento del último turno del asistente se incluyen en las solicitudes posteriores (tokens de entrada)
+ Tokens de salida de texto estándar
**sugerencia**
Cuando se habilita el pensamiento extendido, se incluye automáticamente una petición del sistema de 28 o 29 tokens para respaldar esta característica.
El parámetro `budget_tokens` determina el número máximo de tokens que Claude puede utilizar para su proceso de razonamiento interno. Los presupuestos más grandes pueden mejorar la calidad de la respuesta al permitir un análisis más exhaustivo de los problemas complejos, aunque es posible que Claude no utilice todo el presupuesto asignado, especialmente en intervalos superiores a 32 000.
Con el pensamiento intercalado, `budget_tokens` puede superar el valor del parámetro `max_tokens`, ya que representa el presupuesto total de todos los bloques de pensamiento dentro de un turno de asistente.
Cuando utilice el pensamiento resumido, debe tener en cuenta lo siguiente:
+ **Tokens de entrada**: tokens incluidos en su solicitud original
+ **Tokens de salida (facturados)**: los tokens de pensamiento original que Claude generó internamente
+ **Tokens de salida (visibles)**: los tokens de pensamiento resumido que ve en la respuesta
+ **Sin cargo**: tokens utilizados para generar el resumen
+ El campo `summary_status` puede indicar si los límites de tokens afectan al resumen
+ El recuento de tokens de salida facturados no coincidirá con el recuento de tokens visibles en la respuesta. Se le facturará por todo el proceso de pensamiento, no por el resumen que vea.
# Pensamiento adaptativo
El pensamiento adaptativo es la forma recomendada de utilizar [Pensamiento extendido](claude-messages-extended-thinking.md) la versión Claude Opus 4.6. En lugar de establecer manualmente un presupuesto simbólico para pensar, el pensamiento adaptativo permite decidir de Claude forma dinámica cuándo y cuánto pensar en función de la complejidad de cada solicitud. El pensamiento adaptativo impulsa de forma fiable un mejor rendimiento que el pensamiento extendido con un enfoque fijo`budget_tokens`, por lo que recomendamos pasar al pensamiento adaptativo para obtener las respuestas más inteligentes a partir de la Claude Opus versión 4.6. No se requiere ningún encabezado beta.
Los modelos admitidos son los siguientes:
| Modelo | ID del modelo |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
**nota**
`thinking.type: "enabled"`y `budget_tokens` están en desuso en Claude Opus 4.6 y se eliminarán en una versión futura del modelo. `thinking.type: "adaptive"`Utilícelo con el parámetro effort en su lugar.
Los modelos más antiguos (Claude Sonnet 4.5, Claude Opus 4.5, etc.) no admiten el pensamiento adaptativo y lo requieren `thinking.type: "enabled"``budget_tokens`.
## Cómo funciona el pensamiento adaptativo
En el modo adaptativo, Claude evalúa la complejidad de cada solicitud y decide si piensa en ello y en qué medida. Con el nivel de esfuerzo predeterminado (`high`), casi siempre Claude pensará. Con niveles de esfuerzo más bajos, Claude puede dejar de pensar en problemas más simples.
El pensamiento adaptativo también lo posibilita automáticamente[Pensamiento intercalado (beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved). Esto significa que Claude puede pensar entre llamadas a herramientas, lo que lo hace especialmente eficaz para los flujos de trabajo de los agentes.
`thinking.type`Configúrelo `"adaptive"` en su solicitud de API:
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(
service_name='bedrock-runtime',
region_name='us-east-2'
)
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [{
"role": "user",
"content": "Explain why the sum of two even numbers is always even."
}]
})
)
response_body = json.loads(response["body"].read())
for block in response_body["content"]:
if block["type"] == "thinking":
print(f"\nThinking: {block['thinking']}")
elif block["type"] == "text":
print(f"\nResponse: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: "Explain why the sum of two even numbers is always even."
}]
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
for (const block of responseBody.content) {
if (block.type === "thinking") {
console.log(`\nThinking: ${block.thinking}`);
} else if (block.type === "text") {
console.log(`\nResponse: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Pensamiento adaptativo con el parámetro de esfuerzo
Puede combinar el pensamiento adaptativo con el parámetro de esfuerzo para determinar la cantidad de pensamiento que Claude se necesita para pensar. El nivel de esfuerzo actúa como una guía flexible para Claude la asignación del pensamiento:
| Nivel de esfuerzo | Comportamiento de pensamiento |
| --- | --- |
| max | Claudepiensa siempre sin restricciones en cuanto a la profundidad de pensamiento. Claude OpusSolo en 4.6: las solicitudes que max se utilicen en otros modelos devolverán un error. |
| high (predeterminado) | Claudesiempre piensa. Proporciona un razonamiento profundo sobre tareas complejas. |
| medium | Claudeutiliza un pensamiento moderado. Puede dejar de pensar en consultas muy simples. |
| low | Claudeminimiza el pensamiento. Evita pensar en tareas sencillas en las que la velocidad es lo más importante. |
## Almacenamiento en caché de peticiones
Las solicitudes consecutivas que utilizan `adaptive` Thinking Preserve generan puntos de interrupción en la memoria caché. Sin embargo, al cambiar entre los `adaptive` modos `enabled` `disabled` /thinking se rompen los puntos de interrupción de la caché de los mensajes. Las indicaciones del sistema y las definiciones de herramientas permanecen en caché independientemente de los cambios de modo.
## Ajustar el comportamiento de pensamiento
Si Claude piensa con más o menos frecuencia de la que le gustaría, puede añadir una guía al indicador del sistema:
```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```
**aviso**
ClaudeEmpezar a pensar con menos frecuencia puede reducir la calidad de las tareas que se benefician del razonamiento. Mida el impacto en sus cargas de trabajo específicas antes de implementar ajustes de producción basados en pronósticos. Considere la posibilidad de realizar primero pruebas con niveles de esfuerzo más bajos.
# Cifrado de pensamiento
El contenido de pensamiento completo se cifra y se devuelve en el campo de firma. Este campo se usa para verificar que Claude generó los bloques de pensamiento cuando se pasaron de vuelta a la API. Al transmitir las respuestas, la firma se añade a través de `signature_delta` dentro de un evento `content_block_delta` justo antes del evento `content_block_stop`.
**nota**
Solo es estrictamente necesario devolver los bloques de pensamiento cuando se utilizan herramientas con la característica de pensamiento extendido. De lo contrario, puede omitir los bloques de pensamiento de los turnos anteriores o dejar que la API los elimine por usted si se los volvió a pasar.
Si envía de vuelta los bloques de pensamiento, le recomendamos que lo devuelva todo tal como lo recibió para mantener la coherencia y evitar posibles problemas.
## Redacción de pensamiento en Sonnet Claude 3.7
**nota**
La siguiente información se aplica específicamente a Claude 3.7 Sonnet. Los modelos Claude 4 tratan el pensamiento de manera diferente y no producen bloques de pensamiento redactados.
En Claude 3.7 Sonnet, se aplica lo siguiente.
+ Ocasionalmente, nuestros sistemas de seguridad señalarán el razonamiento interno de Claude. Cuando esto ocurre, ciframos una parte o la totalidad del bloque de pensamiento y se lo devolvemos como un bloque redacted\$1thinking. Los bloques redacted\$1thinking se descifran cuando se devuelven a la API, lo que permite que Claude continúe su respuesta sin perder el contexto.
+ Los bloques `thinking` y `redacted_thinking` se devuelven antes que los bloques de texto de la respuesta.
Al crear aplicaciones orientadas al cliente en las que se utilice el pensamiento ampliado con Claude 3.7 Sonnet, tenga en cuenta lo siguiente:
+ Tenga en cuenta que los bloques de pensamiento redactados contienen contenido cifrado que no es legible para las personas.
+ Considere la posibilidad de proporcionar una explicación sencilla, como la siguiente: “Parte del razonamiento interno de Claude se ha cifrado automáticamente por motivos de seguridad. Esto no afecta a la calidad de las respuestas”.
+ Si muestra bloques de pensamiento a los usuarios, puede filtrar los bloques redactados y, al mismo tiempo, conservar los bloques de pensamiento normales.
+ Sea transparente, ya que el uso de características de pensamiento extendido puede provocar en ocasiones que se cifre parte del razonamiento.
+ Implemente un tratamiento de los errores adecuado para gestionar la característica de pensamiento redactado sin que el funcionamiento de la interfaz de usuario resulte afectado.
Este es un ejemplo que muestra bloques de pensamiento normales y redactados:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature":"WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...." },
{
"type": "redacted_thinking",
"data":"EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpP..."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
**sugerencia**
Ver los bloques de pensamiento redactado en la salida es un comportamiento esperado. El modelo aún puede utilizar este razonamiento redactado para fundamentar sus respuestas y, al mismo tiempo, mantener las barreras de protección.
Si necesita probar el tratamiento del pensamiento redactado en su aplicación, puede usar esta cadena de prueba especial como petición: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Al enviar los bloques `thinking` y `redacted_thinking` de vuelta a la API en una conversación de varios turnos, debe incluir el bloque completo sin modificar correspondiente al último turno de asistente. Esto es fundamental para mantener el flujo de razonamiento del modelo. Le sugerimos que siempre envíe de vuelta todos los bloques de pensamiento a la API. Para obtener más información, consulte [Pensamiento extendido con el uso de herramientasConservación de los bloques de pensamiento](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
El siguiente ejemplo usa la **InvokeModelWithResponseStream**API para demostrar la estructura de solicitudes y respuestas cuando se usan tokens de pensamiento con redacciones.
Cuando la transmisión esté habilitada, recibirá el contenido de pensamiento desde los eventos thinking\$1delta. A continuación, le explicamos cómo gestionar la transmisión con la característica de pensamiento:
**Solicitud**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Respuesta**
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
# Diferencias de la característica de pensamiento entre las versiones de los modelos
La API Messages gestiona el pensamiento de forma diferente en los modelos Claude 3.7 Sonnet y Claude 4, principalmente en lo que respecta al comportamiento de redacción y resumen. En la siguiente tabla se resumen estas diferencias.
| Característica | Claude 3.7 Sonnet | Modelos Claude 4 |
| --- | --- | --- |
| Salida de pensamiento | Devuelve la salida de pensamiento completa | Devuelve el pensamiento resumido |
| Tratamiento de la redacción | Usa bloques `redacted_thinking` | Redacta y cifra el pensamiento completo, devuelto en un campo `signature` |
| Pensamiento intercalado | No compatible | Compatible con un encabezado beta |
# Compactación
**sugerencia**
Se recomienda la compactación del lado del servidor para gestionar el contexto en las conversaciones prolongadas y los flujos de trabajo de los agentes, ya que gestiona la gestión del contexto de forma automática con un trabajo de integración mínimo.
**nota**
La compactación se encuentra actualmente en versión beta. Incluye el encabezado de la versión beta `compact-2026-01-12` en tus solicitudes de API para usar esta función. La Converse API no admite actualmente la compactación, pero sí la admite. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
La compactación amplía la longitud efectiva del contexto para conversaciones y tareas prolongadas al resumir automáticamente el contexto anterior cuando se acerca al límite de la ventana de contexto. Esto es ideal para:
+ Conversaciones de varios turnos basadas en el chat en las que quieres que los usuarios usen un chat durante un período prolongado
+ Mensajes orientados a tareas que requieren mucho trabajo de seguimiento (a menudo, el uso de herramientas) y que pueden superar la ventana contextual de 200 000
La compactación es compatible con los siguientes modelos:
| Modelo | ID del modelo |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**nota**
El nivel superior `input_tokens` y `output_tokens` el de `usage` campo no incluyen el uso de iteraciones de compactación y reflejan la suma de todas las iteraciones sin compactación. Para calcular el total de fichas consumidas y facturadas para una solicitud, suma todas las entradas de la matriz. `usage.iterations`
Si anteriormente se basaba en el `usage.input_tokens` seguimiento o la auditoría de los costes, tendrá que actualizar la lógica de seguimiento para agregarla `usage.iterations` cuando la compactación esté habilitada. `usage.output_tokens` La `iterations` matriz solo está presente cuando se activa una nueva compactación durante la solicitud. Volver a aplicar un `compaction` bloque anterior no supone ningún coste de compactación adicional y, en ese caso, los campos de uso de nivel superior siguen siendo precisos.
## ¿Cómo funciona la compactación
Cuando la compactación está habilitada, resume Claude automáticamente la conversación cuando se acerca al umbral de token configurado. La API:
1. Detecta cuando los tokens de entrada superan el umbral de activación especificado.
1. Genera un resumen de la conversación actual.
1. Crea un `compaction` bloque que contiene el resumen.
1. Continúa la respuesta con el contexto compactado.
En solicitudes posteriores, añada la respuesta a sus mensajes. La API elimina automáticamente todos los bloques de mensajes anteriores al `compaction` bloqueo y continúa la conversación desde el resumen.
## Uso básico
Activa la compactación añadiendo la `compact_20260112` estrategia a tu solicitud `context_management.edits` de la API de Mensajes.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Parámetro | Tipo | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| type | cadena | Obligatorio | Debe ser "compact\$120260112" |
| trigger | objeto | 150 000 fichas | Cuándo activar la compactación. Debe haber al menos 50 000 fichas. |
| pause\$1after\$1compaction | booleano | false | Si se debe hacer una pausa después de generar el resumen de compactación |
| instructions | cadena | null | Solicitud de resumen personalizada. Sustituye por completo al mensaje predeterminado cuando se proporciona. |
## Configuración de desencadenadores
Configure cuándo se desencadena la compactación mediante el `trigger` parámetro:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Instrucciones de resumen personalizadas
De forma predeterminada, la compactación utiliza la siguiente solicitud de resumen:
```
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Puede proporcionar instrucciones personalizadas mediante el `instructions` parámetro para reemplazar esta solicitud por completo. Las instrucciones personalizadas no complementan la predeterminada, sino que la sustituyen por completo:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Pausa después de la compactación
Se utiliza `pause_after_compaction` para pausar la API después de generar el resumen de compactación. Esto te permite añadir bloques de contenido adicionales (por ejemplo, conservar los mensajes recientes o mensajes específicos orientados a instrucciones) antes de que la API continúe con la respuesta.
Cuando está habilitada, la API devuelve un mensaje con el motivo de la `compaction` interrupción después de generar el bloque de compactación:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Trabajando con bloques de compactación
Cuando se activa la compactación, la API devuelve un `compaction` bloque al inicio de la respuesta del asistente.
Una conversación prolongada puede provocar varias compactaciones. El último bloque de compactación refleja el estado final del mensaje y reemplaza el contenido anterior por el resumen generado.
```
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
## Transmisión
Cuando transmitas las respuestas con la compactación habilitada, recibirás un `content_block_start` evento cuando comience la compactación. El flujo del bloque de compactación es diferente al de los bloques de texto. Recibirás un `content_block_start` evento, seguido de un sencillo `content_block_delta` con el resumen completo del contenido (sin transmisión intermedia) y, a continuación, un `content_block_stop` evento.
## Almacenamiento en caché de peticiones
Puedes añadir un `cache_control` punto de interrupción en los bloques de compactación, que almacenará en caché todo el mensaje del sistema junto con el contenido resumido. Se ignora el contenido compactado original. Ten en cuenta que, cuando se activa la compactación, es posible que se pierda la memoria caché en la siguiente solicitud.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Entender el uso
La compactación requiere un paso de muestreo adicional, lo que contribuye a los límites de tarifa y a la facturación. La API devuelve información de uso detallada en la respuesta:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
La `iterations` matriz muestra el uso de cada iteración de muestreo. Cuando se produce la compactación, verá una `compaction` iteración seguida de la iteración principal. `message` Los recuentos de símbolos de la iteración final reflejan el tamaño efectivo del contexto tras la compactación.
# Obtenga resultados JSON validados de los modelos
Puede utilizar salidas estructuradas conClaude Sonnet 4.5, Claude Haiku 4.5Claude Opus 4.5, yClaude Opus 4.6. Para obtener más información, consulte [Obtenga resultados JSON validados de los modelos](structured-output.md).
# Solicitud y respuesta
El cuerpo de la solicitud se pasa en el `body` campo de una solicitud a [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).
**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.
**aviso**
Claude Sonnet 4.5y Claude Haiku 4.5 admiten la especificación del `top_p` parámetro `temperature` o, pero no de ambos. Esto no se aplica a los modelos anteriores.
------
#### [ Request ]
Anthropic Claude tiene los siguientes parámetros de inferencia para realizar una llamada de inferencia de Messages.
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["computer-use-2024-10-22"]
"max_tokens": int,
"system": string,
"messages": [
{
"role": string,
"content": [
{ "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
{ "type": "text", "text": "content text" }
]
}
],
"temperature": float,
"top_p": float,
"top_k": int,
"tools": [
{
"type": "custom",
"name": string,
"description": string,
"input_schema": json
},
{
"type": "computer_20241022",
"name": "computer",
"display_height_px": int,
"display_width_px": int,
"display_number": 0 int
},
{
"type": "bash_20241022",
"name": "bash"
},
{
"type": "text_editor_20241022",
"name": "str_replace_editor"
}
],
"tool_choice": {
"type" : string,
"name" : string,
},
"stop_sequences": [string]
}
```
Los siguientes parámetros son obligatorios.
+ **anthropic\$1version**: (obligatorio) es la versión de Anthropic. El valor debe ser `bedrock-2023-05-31`.
+ **max\$1tokens**: (obligatorio) número máximo de tokens a generar antes de realizar paradas.
Tenga en cuenta que es posible que los modelos Anthropic Claude dejen de generar tokens antes de alcanzar el valor de `max_tokens`. Los distintos modelos de Anthropic Claude tienen valores máximos diferentes para este parámetro. Para obtener más información, consulte [Tabla comparativa de modelos](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages**: (obligatorio) son los mensajes de entrada.
+ **role**: es el rol del turno de conversación. Los valores válidos son `user` y `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** (obligatorio): el contenido del turno de conversación como una matriz de objetos. Cada objeto contiene un campo **type**, en el que puede especificar uno de los siguientes valores:
+ `text`: si especifica este tipo, debe incluir un campo **texto** y especificar la petición de texto como su valor. Si otro objeto de la matriz es una imagen, esta petición de texto se aplica a las imágenes.
+ `image`: si especifica este tipo, debe incluir un campo **origen** que se asigne a un objeto con los siguientes campos:
+ **type**: (obligatorio) es el tipo de codificación de la imagen. Puede especificar `base64`.
+ **media\$1type**: (obligatorio) es el tipo de imagen. Puede especificar los siguientes formatos de imagen.
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data**: (obligatorio) son los bytes de la imagen codificados en base64. El tamaño máximo es 3,75 MB. La altura y el ancho máximos de una imagen son 8000 píxeles.
Los siguientes son parámetros opcionales.
+ **system**: (opcional) es la petición del sistema para la solicitud.
Una petición del sistema le permite proporcionar contexto e instrucciones a Anthropic Claude, por ejemplo, especificar un objetivo o rol en particular. Para obtener más información, consulte [Prompt de sistema](https://docs.anthropic.com/en/docs/system-prompts) en la documentación de Anthropic.
**nota**
Puede utilizar las peticiones del sistema con Anthropic Claude versión 2.1 o superior.
+ **anthropic\$1beta** (opcional): el parámetro anthropic beta es una lista de cadenas de encabezados beta que se utilizan para indicar la suscripción a un conjunto concreto de características beta.
**nota**
La variante de contexto de 1 millón de fichas Claude Sonnet 4 está disponible en determinadas AWS regiones como «servicio beta», tal como se define en las condiciones del AWS servicio. Está sujeto a su acuerdo con AWS él, a las condiciones del AWS servicio y al modelo de EULA aplicable. Consulte la página [Precios de Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/) para obtener más información sobre los precios para solicitudes de contexto más largas. Se aplican cuotas de servicio independientes (para obtener más información, consulte **Service Quotas** en Consola de administración de AWS).
Entre los encabezados beta disponibles se incluyen los siguientes:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequence**: (opcional) secuencias de texto personalizadas que hacen que el modelo deje de generarse. Los modelos Anthropic Claude normalmente se detienen cuando han completado su turno de forma natural; en este caso, el valor del campo de respuesta `stop_reason` es `end_turn`. Si desea que el modelo deje de generar cuando encuentre cadenas de texto personalizadas, puede usar el parámetro `stop_sequences`. Si el modelo encuentra una de las cadenas de texto personalizadas, el valor del campo de respuesta `stop_reason` es `stop_sequence` y el valor de `stop_sequence` contiene la secuencia de paradas correspondiente.
El número máximo de entradas es 8191.
+ **temperature**: (opcional) la cantidad de asignación al azar que se inyecta en la respuesta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p**: (opcional) utilice el muestreo de núcleos.
En el muestreo de núcleos, Anthropic Claude calcula la distribución acumulada entre todas las opciones de cada token subsiguiente en orden de probabilidad decreciente y la corta cuando alcanza una probabilidad determinada especificada por `top_p`. Al ajustar los parámetros de muestreo, modifique `temperature` o `top_p`. No modifique ambos al mismo tiempo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k**: (opcional) solo una muestra de las opciones K superior para cada token subsiguiente.
Use `top_k` para eliminar las respuestas de baja probabilidad de cola larga.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools**: /(opcional) definiciones de las herramientas que puede utilizar el modelo.
**nota**
Requiere un modelo Anthropic Claude 3.
Si incluye `tools` en su solicitud, es posible que el modelo devuelva bloques de contenido de `tool_use` que representen el uso de esas herramientas por parte del modelo. A continuación, puede ejecutar esas herramientas con la entrada de herramientas generada por el modelo y, si lo desea, devolver los resultados al modelo mediante bloques de contenido `tool_result`.
Puede transferir los siguientes tipos de herramientas:
**Personalizada**
Definición de una herramienta personalizada.
+ **type**: (opcional) es el tipo de herramienta. Si está definido, utilice el valor `custom`.
+ **name**: es el nombre de la herramienta.
+ **description**: (opcional, pero muy recomendable) es la descripción de la herramienta.
+ **input\$1schema**: es el esquema JSON de la herramienta.
**Computadora**
Definición de la herramienta informática que se utiliza con la API de Computer Use.
+ **type**: el valor debe ser `computer_20241022`.
+ **name**: el valor debe ser `computer`.
+ (Obligatorio) **display\$1height\$1px**: es la altura de la pantalla que controla el modelo en píxeles.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Obligatorio) **display\$1width\$1px**: es el ancho de la pantalla que controla el modelo en píxeles.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Opcional) **display\$1number**: es el número de pantalla que se va a controlar (solo relevante para los entornos X11). Si se especifica, se proporcionará a la herramienta un número de pantalla en la definición de la herramienta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definición de la herramienta Bash que se utiliza con la API de Computer Use.
+ **type**: (opcional) el valor debe ser `bash_20241022`.
+ **name**: el valor debe ser `bash`. La herramienta.
**editor de texto**
Definición de la herramienta de editor de texto que se utiliza con la API de Computer Use.
+ **type**: (opcional) el valor debe ser `text_editor_20241022`.
+ **name**: el valor debe ser `str_replace_editor`. La herramienta.
+ **tool\$1choice**: (opcional) especifica cómo debe utilizar el modelo las herramientas proporcionadas. El modelo puede usar una herramienta específica, cualquier herramienta disponible o decidir por sí mismo.
**nota**
Requiere un modelo Anthropic Claude 3.
+ **type**: es el tipo de herramienta elegido. Los valores posibles son `any` (usar cualquier herramienta disponible), `auto` (el modelo decide) y `tool` (usar la herramienta especificada).
+ **name**: (opcional) es el nombre de la herramienta que se va a utilizar. Obligatorio si lo especifica `tool` en el campo `type`.
------
#### [ Response ]
El modelo Anthropic Claude devuelve los siguientes campos para realizar una llamada de inferencia a Messages.
```
{
"id": string,
"model": string,
"type" : "message",
"role" : "assistant",
"content": [
{
"type": string,
"text": string,
"image" :json,
"id": string,
"name":string,
"input": json
}
],
"stop_reason": string,
"stop_sequence": string,
"usage": {
"input_tokens": integer,
"output_tokens": integer
}
}
```
Ejemplos de respuestas con nuevos valores de stop\$1reason:
```
// Example with refusal
{
"stop_reason": "refusal",
"content": [
{
"type": "text",
"text": "I can't help with that request."
}
]
}
// Example with tool_use
{
"stop_reason": "tool_use",
"content": [
{
"type": "tool_use",
"id": "toolu_123",
"name": "calculator",
"input": {"expression": "2+2"}
}
]
}
// Example with model_context_window_exceeded (Claude Sonnet 4.5)
{
"stop_reason": "model_context_window_exceeded",
"content": [
{
"type": "text",
"text": "The response was truncated due to context window limits..."
}
]
}
```
+ **id**: es el identificador único de la respuesta. El formato y la longitud del ID pueden cambiar con el tiempo.
+ **model**: el ID del modelo Anthropic Claude que ha realizado la solicitud.
+ **stop\$1reason**: motivo por el que Anthropic Claude ha dejado de generar texto.
+ **end\$1turn**: el modelo ha alcanzado un punto de parada natural.
+ **max\$1tokens**: el texto generado ha superado el valor del campo de entrada `max_tokens` o ha superado el número máximo de tokens que admite el modelo.
+ **stop\$1sequence**: el modelo ha generado una de las secuencias de parada que ha especificado en el campo de entrada `stop_sequences`.
+ **refusal**: Claude se niega a generar una respuesta por motivos de seguridad
+ **tool\$1use**: Claude llama a una herramienta y espera que la ejecute
+ **model\$1context\$1window\$1exceeded**: el modelo detuvo la generación debido a que alcanzó el límite de la ventana de contexto.
+ Nuevo con Claude Sonnet 4.5
+ **stop\$1sequence**: es la secuencia de paradas que ha puesto fin a la generación.
+ **type**: es el tipo de respuesta. Este valor siempre es `message`.
+ **role**: es el rol conversacional del mensaje generado. Este valor siempre es `assistant`.
+ **content**: es el contenido generado por el modelo. Se devuelve en forma de matriz. Hay tres tipos de contenido: *text*, *tool\$1use* e *image*.
+ *text*: es una respuesta de texto.
+ **type**: el tipo de contenido. El valor es `text`.
+ **text**: si el valor de `type` es texto, contiene el texto del contenido.
+ *tool\$1use*: solicitud del modelo para usar una herramienta.
+ **type**: el tipo de contenido. El valor es `tool_use`.
+ **id**: es el ID de la herramienta que el modelo quiere usar.
+ **name**: contiene el nombre de la herramienta solicitada.
+ **input**: parámetros de entrada que se van a transferir a la herramienta.
+ *Image*: solicitud del modelo para usar una herramienta.
+ **type**: el tipo de contenido. El valor es `image`.
+ **source**: contiene la imagen. Para obtener más información, consulte [Peticiones multimodales](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage**: contenedor del número de tokens proporcionados en la solicitud y el número de tokens que el modelo ha generado en la respuesta.
+ **input\$1tokens**: número de tokens de entrada en la solicitud.
+ **output\$1tokens**: número de tokens que el modelo ha generado en la respuesta.
+ **stop\$1sequence**: el modelo ha generado una de las secuencias de parada que ha especificado en el campo de entrada `stop_sequences`.
------
## Parámetro de esfuerzo (beta)
El `effort` parámetro es una alternativa a pensar en presupuestos simbólicos para Claude Opus 4,5. Este parámetro indica la generosidad Claude con la que debería gastar los tokens para obtener el mejor resultado, ajustando el uso de los tokens en función del pensamiento, las llamadas a las herramientas y la comunicación con los usuarios. Se puede usar con o sin el modo de pensamiento extendido.
El parámetro de esfuerzo se puede configurar en:
+ `high`(predeterminado): Claude gasta tantos tokens como sea necesario para obtener el mejor resultado
+ `medium`— Uso equilibrado de los tokens
+ `low`— Uso conservador de los tokens
Para utilizar esta función, debe pasar el encabezado beta`effort-2025-11-24`.
Ejemplo de solicitud:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"effort-2025-11-24"
],
"max_tokens": 4096,
"output_config": {
"effort": "medium"
},
"messages": [{
"role": "user",
"content": "Analyze this complex dataset and provide insights"
}]
}
```
# Ejemplos de código
Los siguientes ejemplos de código muestran cómo usar la API de Messages.
**Topics**
+ [Ejemplo de código de Messages](#api-inference-examples-claude-messages-code-example)
+ [Ejemplos de código multimodal](#api-inference-examples-claude-multimodal-code-example)
## Ejemplo de código de Messages
En este ejemplo se muestra cómo enviar un mensaje de usuario de un solo turno y un turno de usuario con mensaje de asistente rellenado previamente a un modelo Anthropic Claude 3 Sonnet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"system": system_prompt,
"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 message example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
system_prompt = "Please respond only with emoji."
max_tokens = 1000
# Prompt with user turn only.
user_message = {"role": "user", "content": "Hello World"}
messages = [user_message]
response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
print("User turn only.")
print(json.dumps(response, indent=4))
# Prompt with both user turn and prefilled assistant response.
#Anthropic Claude continues by using the prefilled assistant text.
assistant_message = {"role": "assistant", "content": ""}
messages = [user_message, assistant_message]
response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
print("User turn and prefilled assistant response.")
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()
```
## Ejemplos de código multimodal
Los siguientes ejemplos muestran cómo pasar una imagen y un texto de petición de un mensaje multimodal a un modelo Anthropic Claude 3 Sonnet.
**Topics**
+ [Avisos multimodales con InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Transmitir un mensaje multimodal con InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Avisos multimodales con InvokeModel
El siguiente ejemplo muestra cómo enviar una solicitud multimodal a Anthropic Claude 3 Sonnet with. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
```
# 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()
```
### Transmitir un mensaje multimodal con InvokeModelWithResponseStream
El siguiente ejemplo muestra cómo transmitir la respuesta desde una solicitud multimodal enviada a Anthropic Claude 3 Sonnet with. [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a
multimodal request.
"""
import json
import base64
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
"""
Streams the response from a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
input_text (str) : The prompt text
image (str) : The path to an image that you want in the prompt.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": input_text},
{"type": "image", "source": {"type": "base64",
"media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
]
}
]
})
response = bedrock_runtime.invoke_model_with_response_stream(
body=body, modelId=model_id)
for event in response.get("body"):
chunk = json.loads(event["chunk"]["bytes"])
if chunk['type'] == 'message_delta':
print(f"\nStop reason: {chunk['delta']['stop_reason']}")
print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
print(f"Output tokens: {chunk['usage']['output_tokens']}")
if chunk['type'] == 'content_block_delta':
if chunk['delta']['type'] == 'text_delta':
print(chunk['delta']['text'], end="")
def main():
"""
Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
"""
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What can you tell me about this image?"
image = "/path/to/image"
max_tokens = 100
try:
bedrock_runtime = boto3.client('bedrock-runtime')
stream_multi_modal_prompt(
bedrock_runtime, model_id, input_text, image, max_tokens)
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()
```
# Modelos compatibles
Puede usar la API de Messages con los siguientes modelos de Anthropic Claude.
+ AnthropicClaude Opus4.5
+ AnthropicClaude Opus4.1
+ AnthropicClaude Opus4
+ Anthropic Claude Sonnet 4.5
+ Anthropic Claude Haiku 4.5
+ Anthropic Claude Sonnet 4
+ Anthropic Claude 3.7 Sonnet
+ Anthropic Claude 3.5 Sonnet v2
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Anthropic Claude 2 v2.1
+ Anthropic Claude 2 v2
+ Anthropic Claude Instant v1.2
# Modelos de AI21 Labs
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de AI21 Labs. Utilice esta información para realizar llamadas de inferencia a los modelos de AI21 Labs con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de AI21 Labs. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para comprobar si la API Converse es compatible con un modelo de AI21 Labs específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos de AI21 Labs, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos de AI21 Labs, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos de AI21 Labs, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando realiza llamadas de inferencia con modelos de AI21 Labs, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones a AI21 Labs, consulte la [guía de ingeniería de peticiones de AI21 Labs](https://docs.ai21.com/docs/prompt-engineering).
**Topics**
+ [Modelos AI21 Labs Jurassic-2](model-parameters-jurassic2.md)
+ [Modelos AI21 Labs Jamba](model-parameters-jamba.md)
# Modelos AI21 Labs Jurassic-2
En esta sección se proporcionan parámetros de inferencia y un ejemplo de código para utilizar los modelos AI21 Labs AI21 Labs Jurassic-2.
**Topics**
+ [Parámetros de inferencia](#model-parameters-jurassic2-request-response)
+ [Ejemplo de código](#api-inference-examples-a2i-jurassic)
## Parámetros de inferencia
Los modelos AI21 Labs Jurassic-2 admiten los siguientes parámetros de inferencia.
**Topics**
+ [Asignación al azar y diversidad](#model-parameters-jurassic2-random)
+ [Longitud](#model-parameters-jurassic2-length)
+ [Repeticiones](#model-parameters-jurassic2-reps)
+ [Campo del cuerpo de la solicitud de invocación del modelo](#model-parameters-jurassic2-request-body)
+ [Campo de cuerpo de respuesta a la invocación del modelo](#model-parameters-jurassic2-response-body)
### Asignación al azar y diversidad
Los modelos AI21 Labs Jurassic-2 admiten los siguientes parámetros para controlar la asignación al azar y la diversidad en la respuesta.
+ **Temperatura** (`temperature`): utilice un valor más bajo para reducir la asignación al azar de la respuesta.
+ **Top P** (`topP`): utilice un valor más bajo para ignorar las opciones menos probables.
### Longitud
Los modelos AI21 Labs Jurassic-2 admiten los siguientes parámetros para controlar la longitud de la respuesta generada.
+ **Longitud máxima de finalización** (`maxTokens`): especifique la cantidad máxima de tokens para usar en la respuesta generada.
+ **Secuencias de detención** (`stopSequences`): configure las secuencias de detención que el modelo reconoce y, tras lo cual, deja de generar más tokens. Pulse la tecla Intro para insertar un carácter de nueva línea en una secuencia de detención. Utilice la tecla de tabulación para terminar de insertar una secuencia de detención.
### Repeticiones
Los modelos AI21 Labs Jurassic-2 admiten los siguientes parámetros para controlar la repetición de la respuesta generada.
+ **Penalización por presencia** (`presencePenalty`): usa un valor más alto para reducir la probabilidad de generar nuevos tokens que ya aparezcan al menos una vez en la petición o al completarlas.
+ **Penalización por recuento** (`countPenalty`): usa un valor más alto para reducir la probabilidad de generar nuevos tokens que ya aparezcan al menos una vez en la petición o al completarlas. Proporcional al número de apariciones.
+ **Penalización por frecuencia** (`frequencyPenalty`): usa un valor alto para reducir la probabilidad de generar nuevos tokens que ya aparezcan al menos una vez en la petición o al completarlas. El valor es proporcional a la frecuencia con la que aparecen los símbolos (normalizado a la longitud del texto).
+ **Penaliza los tokens especiales**: reduce la probabilidad de que se repitan caracteres especiales. Los valores predeterminados son `true`.
+ **Espacios en blanco** (`applyToWhitespaces`): un valor `true` aplica la penalización a los espacios en blanco y a las líneas nuevas.
+ **Puntuaciones** (`applyToPunctuation`): un valor `true` aplica la penalización a la puntuación.
+ **Números** (`applyToNumbers`): un valor `true` aplica la penalización a los números.
+ **Palabras de parada** (`applyToStopwords`): un valor `true` aplica la penalización a las palabras de parada.
+ **Emojis** (`applyToEmojis`): un valor `true` excluye los emojis de la penalización.
### Campo del cuerpo de la solicitud de invocación del modelo
Cuando realice una llamada a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) con un modelo AI21 Labs, rellene el campo `body` con un objeto JSON que se ajuste al siguiente. Introduzca la petición en el campo `prompt`.
```
{
"prompt": string,
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": [string],
"countPenalty": {
"scale": float
},
"presencePenalty": {
"scale": float
},
"frequencyPenalty": {
"scale": float
}
}
```
Para penalizar los tokens especiales, agregue esos campos a cualquiera de los objetos de penalización. Por ejemplo, puede modificar el campo `countPenalty` de la siguiente manera.
```
"countPenalty": {
"scale": float,
"applyToWhitespaces": boolean,
"applyToPunctuations": boolean,
"applyToNumbers": boolean,
"applyToStopwords": boolean,
"applyToEmojis": boolean
}
```
La siguiente tabla muestra los valores mínimo, máximo y predeterminado de los parámetros numéricos.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-jurassic2.html)
### Campo de cuerpo de respuesta a la invocación del modelo
Para obtener información sobre el formato del campo `body` de la respuesta, consulte [https://docs.ai21.com/reference/j2-complete-api-ref](https://docs.ai21.com/reference/j2-complete-api-ref).
**nota**
Amazon Bedrock devuelve el identificador de respuesta (`id`) como valor entero.
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *A2I AI21 Labs Jurassic-2 Mid*.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "Translate to spanish: 'Amazon Bedrock is the easiest way to build and scale generative AI applications with base models (FMs)'.",
"maxTokens": 200,
"temperature": 0.5,
"topP": 0.5
})
modelId = 'ai21.j2-mid-v1'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(
body=body,
modelId=modelId,
accept=accept,
contentType=contentType
)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completions')[0].get('data').get('text'))
```
# Modelos AI21 Labs Jamba
En esta sección se proporcionan parámetros de inferencia y un ejemplo de código para utilizar los modelos AI21 Labs Jamba.
**Topics**
+ [Campos obligatorios](#model-parameters-jamba-required-fields)
+ [Parámetros de inferencia](#model-parameters-jamba-request-response)
+ [Campo del cuerpo de la solicitud de invocación del modelo](#model-parameters-jamba-request-body)
+ [Campo de cuerpo de respuesta a la invocación del modelo](#model-parameters-jamba-response-body)
+ [Ejemplo de código](#api-inference-examples-a2i-jamba)
+ [Ejemplo de código de Jamba 1.5 Large](#api-inference-examples-a2i-jamba15-large)
## Campos obligatorios
Los modelos AI21 Labs Jamba admiten los siguientes campos obligatorios:
+ **Mensajes** (`messages`): son los mensajes anteriores de este chat, desde el más antiguo (índice 0) al más reciente. Debe haber al menos un mensaje de usuario o asistente en la lista. Incluya tanto las entradas de los usuarios como las respuestas del sistema. El tamaño total máximo de la lista es de aproximadamente 256 000 tokens. Cada mensaje incluye los siguientes miembros:
+ **Rol** (`role`): es el rol del autor del mensaje. Uno de los valores siguientes:
+ **Usuario** (`user`): entrada proporcionada por el usuario. Cualquier instrucción que se dé aquí y que contradiga las instrucciones de la petición `system` tiene prioridad sobre las instrucciones de la petición `system`.
+ **Asistente** (`assistant`): respuesta generada por el modelo.
+ **Sistema** (`system`): instrucciones iniciales proporcionadas al sistema para proporcionar instrucciones generales sobre el tono y la voz del mensaje generado. Un mensaje inicial del sistema es opcional, pero se recomienda para informar sobre el tono del chat. Por ejemplo, “Eres un chatbot de ayuda formado en ciencias de la tierra y con un encantador acento francés”.
+ **Contenido** (`content`): es el contenido del mensaje.
## Parámetros de inferencia
Los modelos AI21 Labs Lambda admiten los siguientes parámetros de inferencia.
**Topics**
+ [Asignación al azar y diversidad](#model-parameters-jamba-random)
+ [Longitud](#model-parameters-jamba-length)
+ [Repeticiones](#model-parameters-jamba-reps)
### Asignación al azar y diversidad
Los modelos AI21 Labs Jamba admiten los siguientes parámetros para controlar la asignación al azar y la diversidad en la respuesta.
+ **Temperatura** (`temperature`): nivel de variación que se debe proporcionar en cada respuesta. Si se establece en 0, se garantiza que siempre habrá la misma respuesta a la misma pregunta. Si se establece un valor mayor, se fomenta una mayor variedad en la respuesta. Modifica la distribución a partir de la que se toman muestras de los tokens. Predeterminado: 1,0; rango: de 0,0 a 2,0
+ **P superior** (`top_p`): limita el grupo de tokens que sigue en cada paso al percentil N superior de los tokens posibles, donde 1,0 significa el grupo de todos los tokens posibles y 0,01 significa el grupo de solo los siguientes tokens más probables.
### Longitud
Los modelos AI21 Labs Jamba admiten los siguientes parámetros para controlar la longitud de la respuesta generada.
+ **Longitud máxima de finalización** (`max_tokens`): es la cantidad máxima de tokens permitida para cada mensaje de respuesta generado. Por lo general, la mejor forma de limitar la longitud de la salida es proporcionar un límite de longitud en la petición del sistema (por ejemplo, “limite las respuestas a tres frases”). Predeterminado: 4096, rango: de 0 a 4096.
+ **Secuencias de parada** (`stop`): finaliza el mensaje cuando el modelo genera una de estas cadenas. La secuencia de parada no está incluida en el mensaje generado. Cada secuencia puede tener una longitud máxima de 64 000 y puede contener líneas nuevas en forma de \$1n caracteres.
Ejemplos:
+ Cadena de parada única con una palabra y un punto: “monos”.
+ Varias cadenas de paradas y una nueva línea: [“gato”, “perro”, “ .”, “\$1\$1\$1\$1”, “/n”]
+ **Número de respuestas** (`n`): cuántas respuestas de chat se van a generar. Las notas n deben ser 1 para las respuestas de transmisión. Si n se establece en un valor mayor que 1, la configuración `temperature=0` siempre fallará porque se garantiza que todas las respuestas estén duplicadas. Predeterminado: 1, rango: de 1 a 16
### Repeticiones
Los modelos AI21 Labs Jamba admiten los siguientes parámetros para controlar la repetición de la respuesta generada.
+ **Penalización de frecuencia** (`frequency_penalty`): reduce la frecuencia de palabras repetidas en un solo mensaje de respuesta aumentando dicho número. Esta penalización aumenta gradualmente la repetición de una palabra durante la generación de la respuesta. Si se establece en 2,0, se producirá una cadena con pocas o ninguna palabra repetida.
+ **Penalización de presencia** (`presence_penalty`): reduce la frecuencia de palabras repetidas dentro de un solo mensaje aumentando dicho número. A diferencia de la penalización por frecuencia, la penalización por presencia es la misma independientemente del número de veces que aparezca una palabra.
## Campo del cuerpo de la solicitud de invocación del modelo
Cuando realice una llamada a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) con un modelo AI21 Labs, rellene el campo `body` con un objeto JSON que se ajuste al siguiente. Introduzca la petición en el campo `prompt`.
```
{
"messages": [
{
"role":"system", // Non-printing contextual information for the model
"content":"You are a helpful history teacher. You are kind and you respond with helpful content in a professional manner. Limit your answers to three sentences. Your listener is a high school student."
},
{
"role":"user", // The question we want answered.
"content":"Who was the first emperor of rome?"
}
],
"n":1 // Limit response to one answer
}
```
## Campo de cuerpo de respuesta a la invocación del modelo
Para obtener información sobre el formato del campo `body` de la respuesta, consulte [https://docs.ai21.com/reference/jamba-instruct-api\$1response-details](https://docs.ai21.com/reference/jamba-instruct-api#response-details).
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *AI21 Labs Jamba-Instruct*.
**`invoke_model`**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.invoke_model(
modelId='ai21.jamba-instruct-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
**converse**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.converse(
modelId='ai21.jamba-instruct-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
## Ejemplo de código de Jamba 1.5 Large
En este ejemplo se muestra cómo llamar al modelo *AI21 Labs Jamba 1.5 Large*.
**`invoke_model`**
```
POST https://bedrock-runtime.us-east-1.amazonaws.com/model/ai21.jamba-1-5-mini-v1:0/invoke-model HTTP/1.1
{
"messages": [
{
"role": "system",
"content": "You are a helpful chatbot with a background in earth sciences and a charming French accent."
},
{
"role": "user",
"content": "What are the main causes of earthquakes?"
}
],
"max_tokens": 512,
"temperature": 0.7,
"top_p": 0.9,
"stop": ["###"],
"n": 1
}
```
# Modelos de Cohere
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de Cohere. Utilice esta información para realizar llamadas de inferencia a los modelos de Cohere con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de Cohere. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para comprobar si la API Converse es compatible con un modelo de Cohere específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos de Cohere, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos de Cohere, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos de Cohere, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando realiza llamadas de inferencia con modelos de Cohere, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones a Cohere, consulte la [guía de ingeniería de peticiones de Cohere](https://txt.cohere.com/how-to-train-your-pet-llm-prompt-engineering).
**Topics**
+ [Modelos Cohere Command](model-parameters-cohere-command.md)
+ [Modelos Cohere Embed y Cohere Embed v4](model-parameters-embed.md)
+ [Modelos Cohere Command R y Command R\$1](model-parameters-cohere-command-r-plus.md)
# Modelos Cohere Command
Puede realizar solicitudes de inferencia a un modelo Cohere Command con [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) (transmisión). Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
**Topics**
+ [Solicitud y respuesta](#model-parameters-cohere-command-request-response)
+ [Ejemplo de código](#api-inference-examples-cohere-command)
## Solicitud y respuesta
------
#### [ Request ]
Los modelos Cohere Command tienen los siguientes parámetros de inferencia.
```
{
"prompt": string,
"temperature": float,
"p": float,
"k": float,
"max_tokens": int,
"stop_sequences": [string],
"return_likelihoods": "GENERATION|ALL|NONE",
"stream": boolean,
"num_generations": int,
"logit_bias": {token_id: bias},
"truncate": "NONE|START|END"
}
```
Los siguientes parámetros son obligatorios.
+ **prompt**: (obligatorio) texto de entrada que sirve como punto de partida para generar la respuesta.
Los siguientes son los límites de texto por llamada y de caracteres.
**Textos por llamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
Los siguientes son parámetros opcionales.
+ **return\$1likelihoods**: especifica cómo y si se devuelven las probabilidades simbólicas con la respuesta. Puede especificar las opciones siguientes:
+ `GENERATION`: solo devuelve las probabilidades de los tokens generados.
+ `ALL`: devuelve las probabilidades de todos los tokens.
+ `NONE`: (predeterminado) no devuelvas ninguna probabilidad.
+ **stream**: (necesario para admitir la transmisión) especifique `true` para devolver la respuesta pieza por pieza en tiempo real y `false` para devolver la respuesta completa una vez finalizado el proceso.
+ **logit\$1bias**: evita que el modelo genere tokens no deseados o incentiva al modelo a incluir los tokens deseados. El formato es `{token_id: bias}` en el que el sesgo es un número flotante entre -10 y 10. Los tokens se pueden obtener a partir del texto mediante cualquier servicio de tokenización, como el punto de conexión Tokenize de Cohere. Para obtener más información, consulte [Documentación de Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations**: número máximo de generaciones que debe devolver el modelo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate**: especifica cómo gestiona la API las entradas que superen la longitud máxima del token. Utilice una de las siguientes:
+ `NONE`: devuelve un error cuando la entrada supera la longitud máxima del token de entrada.
+ `START`: descarta el inicio de la entrada.
+ `END`: (predeterminado) descarta el final de la entrada.
Si especifica `START` o`END`, el modelo descarta la entrada hasta que la entrada restante tenga exactamente la longitud máxima del token de entrada para el modelo.
+ **temperature**: utilice un valor bajo para reducir la asignación al azar de la respuesta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **p**: P superior. Utilice un valor bajo para ignorar las opciones menos probables. Configúrelo en 0 o 1,0 para deshabilitarlo. Si ambos `p` y `k` están activados, `p` actúa después `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k**: K superior. Especifique el número de opciones de token que el modelo utiliza para generar el siguiente token. Si ambos `p` y `k` están activados, `p` actúa después `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens**: especifique la cantidad máxima de tokens para usar en la respuesta generada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences**: configure hasta cuatro secuencias que reconozca el modelo. Tras una secuencia de detención, el modelo deja de generar más tokens. El texto devuelto no contiene la secuencia de detención.
------
#### [ Response ]
La respuesta tiene los siguientes campos posibles:
```
{
"generations": [
{
"finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
"id": string,
"text": string,
"likelihood" : float,
"token_likelihoods" : [{"token" : string, "likelihood": float}],
"is_finished" : true | false,
"index" : integer
}
],
"id": string,
"prompt": string
}
```
+ `generations`: una lista de los resultados generados junto con las probabilidades de que se soliciten los tokens. (Siempre se devuelve). Cada objeto de generación de la lista incluye los siguientes campos:
+ `id`: un identificador para la generación. (Siempre se devuelve).
+ `likelihood`: la probabilidad de la salida. El valor es el promedio de las probabilidades del token en `token_likelihoods`. Se devuelve si se especifica el parámetro de entrada `return_likelihoods`.
+ `token_likelihoods`: un conjunto de probabilidades por token. Se devuelve si se especifica el parámetro de entrada `return_likelihoods`.
+ `finish_reason`: indica la razón por la que el modelo ha terminado de generar tokens. `COMPLETE`: el modelo ha enviado una respuesta finalizada. `MAX_TOKENS`: la respuesta se ha interrumpido porque el modelo ha alcanzado el número máximo de tokens para su longitud de contexto. `ERROR `: algo ha salido mal al generar la respuesta. `ERROR_TOXIC`: el modelo ha generado una respuesta considerada tóxica. `finish_reason`: se devuelve solo cuando `is_finished`=`true`. (No siempre se devuelve).
+ `is_finished`: un campo booleano que se usa solo cuando `stream` es `true`, lo que indica si hay o no tokens adicionales que se generarán como parte de la respuesta de la transmisión. (No siempre se devuelve).
+ `text`: el texto generado.
+ `index`: en una respuesta de transmisión, se usa para determinar a qué generación pertenece un token determinado. Cuando solo se transmite una respuesta, todos los tokens pertenecen a la misma generación y no se devuelve el índice. Por lo tanto, `index` solo se devuelve en una solicitud de transmisión con un valor para `num_generations` superior a uno.
+ `prompt`: petición de la solicitud de entrada (se devuelve siempre).
+ `id`: un identificador de la solicitud (siempre devuelto).
Para obtener más información, consulte [Generate](https://docs.cohere.com/reference/generate-1) en la documentación de Cohere.
------
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *Cohere Command*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
accept = 'application/json'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated text with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-text-v14'
prompt = """Summarize this dialogue:
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
try:
body = json.dumps({
"prompt": prompt,
"max_tokens": 200,
"temperature": 0.6,
"p": 1,
"k": 0,
"num_generations": 2,
"return_likelihoods": "GENERATION"
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
generations = response_body.get('generations')
for index, generation in enumerate(generations):
print(f"Generation {index + 1}\n------------")
print(f"Text:\n {generation['text']}\n")
if 'likelihood' in generation:
print(f"Likelihood:\n {generation['likelihood']}\n")
print(f"Reason: {generation['finish_reason']}\n\n")
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 text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos Cohere Embed y Cohere Embed v4
Realizará solicitudes de inferencia a un Embed modelo con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y para ello necesitará el ID del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
**nota**
Amazon Bedrock no admite las respuestas de transmisión de los modelos Cohere Embed.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
Cohere Embed v4 es un modelo de incrustación multimodal que admite entradas de texto e imágenes. Puede procesar contenido de texto e imagen intercalado, lo que lo hace ideal para aplicaciones de comprensión de documentos, búsqueda visual y recuperación multimodal. El modelo admite varios tipos de incrustación, incluidos los formatos float, int8, uint8, binary y ubinary, con dimensiones de salida configurables de 256 a 1536.
El ID de modelo de Cohere Embed v4 es `cohere.embed-v4`.
**Notas de uso adicionales**
+ **Longitud del contexto:** se admiten hasta 128 000 tokens aproximadamente; en el caso de RAG, los fragmentos más pequeños suelen mejorar la recuperación y el costo.
+ **Tamaño de la imagen**: las imágenes de más de 2 458 624 píxeles se reducen a ese tamaño; las imágenes de menos de 3136 píxeles se amplían.
+ **Entradas intercaladas:** es preferible usar inputs.content[] para contenido multimodal de tipo página, de modo que el contexto del texto (por ejemplo, el nombre del archivo o las entidades) se mantenga asociado a la imagen.
**Topics**
+ [Solicitud y respuesta](#model-parameters-embed-v4-request-response)
+ [Solicitud y respuesta para distintos tipos de entrada](#api-inference-examples-cohere-embed-v4)
+ [Ejemplos de código](#code-examples-cohere-embed-v4)
## Solicitud y respuesta
------
#### [ Request ]
Content-type: application/json
```
{
"input_type": "search_document | search_query | classification | clustering",
"texts": ["..."], // optional; text-only
"images": ["data:;base64,..."], // optional; image-only
"inputs": [
{ "content": [
{ "type": "text", "text": "..." },
{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }
]
}
], // optional; mixed (interleaved) text+image
"embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
"output_dimension": 256 | 512 | 1024 | 1536,
"max_tokens": 128000,
"truncate": "NONE | LEFT | RIGHT"
}
```
**Parameters**
+ **input\$1type** (obligatorio): añade tokens especiales para distinguir los casos de uso. Se permiten: `search_document`, `search_query`, `classification`, `clustering`. Para búsqueda y RAG, incruste su corpus con `search_document` y las consultas con `search_query`.
+ **texts** (opcional): matriz de cadenas que se van a incrustar. Máximo de 96 por llamada. Si usa `texts`, no envíe `images` en la misma llamada.
+ **images** (opcional): matriz de imágenes en base64 con URI de datos que se van a incrustar. Máximo de 96 por llamada. No envíe `texts` y `images` juntos. (Use `inputs` para intercalar).
+ **entradas** (opcional; mixed/fused modalidad): lista en la que cada elemento tiene una lista de contenido de piezas. Cada parte es `{ "type": "text", "text": ... }` o `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Envíe aquí contenido intercalado de tipo página (por ejemplo, una imagen de una página en PDF más un subtítulo o metadatos). Máximo de 96 elementos.
+ **embedding\$1types** (opcional): uno o más de: `float`, `int8`, `uint8`, `binary`, `ubinary`. Si se omite, devuelve incrustaciones flotantes.
+ **output\$1dimension** (opcional): sirve para seleccionar la longitud del vector. Permitidos: `256`, `512`, `1024`, `1536` (el valor predeterminado es `1536` si no se especifica un valor).
+ **max\$1tokens** (opcional): presupuesto de truncamiento por objeto de entrada. El modelo admite hasta aproximadamente 128 000 tokens; si es necesario, se pueden usar fragmentos más pequeños para RAG.
+ **truncate** (opcional): cómo gestionar entradas demasiado largas: `LEFT` elimina los tokens del inicio, `RIGHT` los elimina del final y `NONE` devuelve un error si la entrada supera el límite.
**Límites y tamaño**
+ Elementos por solicitud: hasta 96 imágenes. El tipo de archivo de imagen original debe estar en formato png, jpeg, webp o gif y puede tener un tamaño máximo de 5 MB.
+ Tamaño máximo de la solicitud: carga útil total de aproximadamente 20 MB.
+ Número máximo de tokens de entrada: 128 000 tokens como máximo. Los archivos de imagen se convierten en tokens y el total de tokens debe ser inferior a 128 000.
+ Imágenes: un máximo de 2 458 624 píxeles antes de reducir el tamaño de la imagen; las imágenes de menos de 3136 píxeles se amplían. Proporcione las imágenes como `data:;base64,....`
+ Contabilidad de tokens (por elemento `inputs`): tokens de una entrada de imagen ≈ (píxeles de imagen ÷ 784) x 4 tokens de una entrada de texto e imagen intercaladas = (píxeles de imagen ÷ 784) x 4 \$1 (tokens de texto)
**Consejo:** Para ello PDFs, convierte cada página en una imagen y envíala `inputs` junto con los metadatos de la página (p. ej., nombre\$1archivo o entidades) en partes de texto adyacentes.
------
#### [ Response ]
Content-type: application/json
Si ha solicitado un único tipo de incrustación (por ejemplo, solo `float`):
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Si ha solicitado varios tipos de incrustación (por ejemplo, `["float","int8"]`):
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ El número de vectores devueltos coincide con la longitud de la matriz `texts` o el número de elementos `inputs`.
+ La longitud de cada vector es igual a `output_dimension` (`1536` de forma predeterminada).
------
## Solicitud y respuesta para distintos tipos de entrada
**A) Página intercalada (imagen \$1 pie de foto) con vectores int8 compactos**
**Solicitud**
```
{
"input_type": "search_document",
"inputs": [
{
"content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
]
}
],
"embedding_types": ["int8"],
"output_dimension": 512,
"truncate": "RIGHT",
"max_tokens": 128000
}
```
**Respuesta (truncada)**
```
{
"id": "836a33cc-61ec-4e65-afaf-c4628171a315",
"embeddings": { "int8": [[ 7, -3, ... ]] },
"response_type": "embeddings_by_type",
"inputs": [
{ "content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
] }
]
}
```
**B) Indexación de corpus solo de texto (float por defecto, 1536 dimensiones)**
**Solicitud**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Respuesta (ejemplo)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Ejemplos de código
------
#### [ Text input ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-v4:0'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Mixed modalities ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
text = "hello world"
model_id = 'cohere.embed-v4:0'
input_type = "search_document"
image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
embedding_types = ["int8","float"]
try:
body = json.dumps({
"inputs": [
{
"content": [
{ "type": "text", "text": text },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
]
}
],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("inputs")
for i, input in enumerate(response_body.get('inputs')):
print(f"\tinput {i}: {input}")
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 embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Cohere Embed v3
**Topics**
+ [Solicitud y respuesta](#model-parameters-embed-v3-request-response)
+ [Ejemplo de código](#api-inference-examples-cohere-embed-v3)
## Solicitud y respuesta
------
#### [ Request ]
Los modelos Cohere Embed tienen los siguientes parámetros de inferencia.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Los siguientes parámetros son obligatorios.
+ **texts**: una matriz de cadenas para que el modelo las incruste. Para un rendimiento óptimo, recomendamos reducir la longitud de cada texto a menos de 512 tokens. 1 token tiene unos 4 caracteres.
Los siguientes son los límites de texto por llamada y de caracteres.
**Textos por llamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type**: antepone tokens especiales para diferenciar cada tipo entre sí. No se deben mezclar tipos diferentes, excepto cuando se mezclan tipos para la búsqueda y la recuperación. En este caso, incruste el corpus con el tipo `search_document` y las consultas incrustadas con el tipo `search_query`.
+ `search_document`: en los casos de uso de búsquedas, use `search_document` cuando codifique documentos para incrustarlos y guardarlos en una base de datos vectorial.
+ `search_query`: use `search_query` al consultar su base de datos vectorial para encontrar documentos relevantes.
+ `classification`: use `classification` cuando utilice incrustaciones como entrada a un clasificador de texto.
+ `clustering`: use `clustering` para agrupar las incrustaciones.
+ `images`: es una matriz de imágenes.
+ Una matriz de URI de datos de imagen para que el modelo los incruste. El número máximo de imágenes por llamada es 1 (es decir, el modelo solo admite una entrada de imagen).
+ La imagen debe ser un URI de datos válido. La imagen debe estar en formato image/jpeg o image/png y tener un tamaño máximo de 5 MB.
+ Solo se deben proporcionar “imágenes” o “textos”.
Los siguientes parámetros son opcionales:
+ **truncate**: especifica cómo gestiona la API las entradas que superen la longitud máxima del token. Utilice una de las siguientes:
+ `NONE`: (predeterminado) devuelve un error cuando la entrada supera la longitud máxima del token de entrada.
+ `START`: descarta el inicio de la entrada.
+ `END`: descarta el final de la entrada.
Si especifica `START` o`END`, el modelo descarta la entrada hasta que la entrada restante tenga exactamente la longitud máxima del token de entrada para el modelo.
+ **embedding\$1types**: especifica los tipos de incrustaciones que desea que se devuelvan. Es opcional pero el valor predeterminado es `None`, que devuelve el tipo de respuesta `Embed Floats`. Puede tratarse de uno o más de los siguientes tipos:
+ `float`: utilice este valor para devolver las incrustaciones flotantes predeterminadas.
+ `int8`: utilice este valor para devolver las incrustaciones int8 firmadas.
+ `uint8`: utilice este valor para devolver las incrustaciones int8 no firmadas.
+ `binary`: utilice este valor para devolver las incrustaciones binarias firmadas.
+ `ubinary`: utilice este valor para devolver las incrustaciones binarias no firmadas.
Para obtener más información, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) en la documentación de Cohere.
------
#### [ Response ]
La respuesta `body` de una llamada a `InvokeModel` es la siguiente:
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
La respuesta `body` tiene los siguientes campos posibles:
+ **id**: identificador de la respuesta.
+ **response\$1type**: es el tipo de respuesta. Este valor siempre es `embeddings_floats`.
+ **incrustaciones**: una matriz de incrustaciones, en la que cada incrustación es una matriz de elementos flotantes con 1024 elementos. La longitud de la matriz `embeddings` será la misma que la longitud de la matriz `texts` original.
+ **textos**: una matriz que contiene las entradas de texto para las que se devolvieron las incrustaciones.
+ **images**: una matriz de descripciones para cada entrada de imagen.
`image_description`image\$1description tiene este formato:
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Si se utilizó una imagen como entrada, el campo `“texts”` de la respuesta será una matriz vacía. No ocurre así al revés: cuando se usen textos, las `“images”` no estarán en la respuesta.
Para obtener más información, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *Cohere Embed English*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Imagen de entrada**
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_image_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
model_id = 'cohere.embed-english-v3'
input_type = "image"
images = [get_base64_image_uri(image_file_path, image_mime_type)]
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"images": images,
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_image_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos Cohere Command R y Command R\$1
Puede realizar solicitudes de inferencia a modelos Cohere Command R y Cohere Command R\$1 con [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) (transmisión). Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
**sugerencia**
Para las aplicaciones conversacionales, le recomendamos que utilice la API Converse. La API Converse proporciona un conjunto unificado de parámetros que funcionan en todos los modelos que admiten mensajes. Para obtener más información, consulte [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md).
**Topics**
+ [Solicitud y respuesta](#model-parameters-cohere-command-request-response)
+ [Ejemplo de código](#api-inference-examples-cohere-command-r)
## Solicitud y respuesta
------
#### [ Request ]
Los modelos Cohere Command tienen los siguientes parámetros de inferencia.
```
{
"message": string,
"chat_history": [
{
"role":"USER or CHATBOT",
"message": string
}
],
"documents": [
{"title": string, "snippet": string},
],
"search_queries_only" : boolean,
"preamble" : string,
"max_tokens": int,
"temperature": float,
"p": float,
"k": float,
"prompt_truncation" : string,
"frequency_penalty" : float,
"presence_penalty" : float,
"seed" : int,
"return_prompt" : boolean,
"tools" : [
{
"name": string,
"description": string,
"parameter_definitions": {
"parameter name": {
"description": string,
"type": string,
"required": boolean
}
}
}
],
"tool_results" : [
{
"call": {
"name": string,
"parameters": {
"parameter name": string
}
},
"outputs": [
{
"text": string
}
]
}
],
"stop_sequences": [string],
"raw_prompting" : boolean
}
```
Los siguientes parámetros son obligatorios.
+ **message**: (obligatorio) entrada de texto a la que debe responder el modelo.
Los siguientes son parámetros opcionales.
+ **chat\$1history**: lista de los mensajes anteriores entre el usuario y el modelo, que debe proporcionar al modelo un contexto conversacional para responder al mensaje del usuario.
Los siguientes campos son obligatorios.
+ `role`: es el rol para el mensaje. Los valores válidos son los tokens `USER` o `CHATBOT`.
+ `message`: contenido del texto del mensaje.
A continuación, se muestra un ejemplo de JSON para el campo `chat_history`.
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
+ **documents**: lista de textos que el modelo puede citar para generar una respuesta más precisa. Cada documento es un diccionario de cadena con cadena. La generación resultante incluye citas que hacen referencia a algunos de estos documentos. Le recomendamos que mantenga el recuento total de palabras de las cadenas del diccionario por debajo de 300 palabras. Opcionalmente, se puede proporcionar un campo `_excludes` (matriz de cadenas) para omitir que algunos pares clave-valor se muestren en el modelo. Para obtener más información, consulte [Document Mode guide](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) en la documentación de Cohere.
A continuación, se muestra un ejemplo de JSON para el campo `documents`.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
+ **search\$1queries\$1only**: el valor predeterminado es `false`. Si es `true`, la respuesta solo contendrá una lista de las consultas de búsqueda generadas, pero no se realizará ninguna búsqueda ni se generará ninguna respuesta del modelo al `message` del usuario.
+ **preamble**: anula el preámbulo predeterminado para la generación de consultas de búsqueda. No afecta a las generaciones de uso de herramientas.
+ **max\$1tokens**: cantidad máxima de tokens que el modelo debe generar para la respuesta. Tenga en cuenta que establecer un valor bajo puede provocar generaciones incompletas. Si establece `max_tokens`, las generaciones pueden ser incompletas o nulas al usarse con los campos `tools` o `documents`.
+ **temperature**: utilice un valor bajo para reducir la asignación al azar de la respuesta. La asignación al azar se puede maximizar aún más aumentando el valor del parámetro `p`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **p**: P superior. Utilice un valor bajo para ignorar las opciones menos probables.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k**: K superior. Especifique el número de opciones de token que el modelo utiliza para generar el siguiente token.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation**: el valor predeterminado es `OFF`. Determina cómo se construye la petición. Si `prompt_truncation` se establece en `AUTO_PRESERVE_ORDER`, se eliminarán algunos elementos de `chat_history` y `documents` para crear una petición que se ajuste al límite de longitud del contexto del modelo. Durante este proceso, se conservará el orden de los documentos y el historial de chat. Si `prompt_truncation` se establece en `OFF`, no se eliminará ningún elemento.
+ **frequency\$1penalty**: se usa para reducir la repetitividad de los tokens generados. Cuanto mayor sea el valor, mayor será la penalización que se aplicará a los tokens presentados anteriormente, proporcionalmente al número de veces que ya hayan aparecido en la petición o en la generación anterior.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty**: se usa para reducir la repetitividad de los tokens generados. Es similar a `frequency_penalty`, excepto que esta penalización se aplica por igual a todos los tokens que ya han aparecido, independientemente de su frecuencia exacta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed**: si se especifica, el backend hará todo lo posible para sacar muestras de los tokens de forma determinista, para que las solicitudes repetidas con la misma semilla y los mismos parámetros devuelvan el mismo resultado. Sin embargo, no se puede garantizar que sea totalmente determinista.
+ **return\$1prompt**: especifique `true` para que se devuelva la petición completa que se ha enviado al modelo. El valor predeterminado es `false`. En la respuesta, observe el valor del campo `prompt`.
+ **tools**: lista de las herramientas (funciones) disponibles que el modelo puede sugerir que se invoquen antes de generar una respuesta de texto. Cuando se pasa `tools` (sin `tool_results`), el campo `text` de la respuesta será `""` y el campo `tool_calls` de la respuesta se rellenará con una lista de las llamadas a las herramientas que se deben realizar. Si no es necesario realizar ninguna llamada, la matriz `tool_calls` estará vacía.
Para obtener más información, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) en la documentación de Cohere.
**sugerencia**
Le recomendamos que utilice la API Converse para integrar el uso de la herramienta en la aplicación. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
A continuación, se muestra un ejemplo de JSON para el campo `tools`.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameter_definitions": {
"sign": {
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
"type": "str",
"required": true
}
}
}
]
```
Para obtener más información, consulte [Single-Step Tool Use (Function Calling)](https://docs.cohere.com/docs/tool-use) en la documentación de Cohere.
+ **tools\$1results**: lista de los resultados de la invocación de las herramientas recomendados por el modelo en el turno de chat anterior. Los resultados se utilizan para producir una respuesta de texto. Además, se hace referencia a ellos en las citas. Cuando se usa `tool_results`, también se debe pasar `tools`. Cada `tool_result` contiene información sobre cómo se ha invocado, así como una lista de resultados en forma de diccionarios. La lógica de citas única y detallada de Cohere requiere que el resultado tenga forma de lista. En caso de que el resultado sea de solo un elemento, por ejemplo `{"status": 200}`, deberá incluirlo igualmente en una lista.
Para obtener más información, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) en la documentación de Cohere.
A continuación, se muestra un ejemplo de JSON para el campo `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\$1sequences**: lista de secuencias de parada. Tras una secuencia de parada, el modelo deja de generar más tokens.
+ **raw\$1prompting**: especifique `true` si desea enviar el `message` del usuario al modelo sin preprocesamiento; de lo contrario, será falso.
------
#### [ Response ]
La respuesta tiene los siguientes campos posibles:
```
{
"response_id": string,
"text": string,
"generation_id": string,
"citations": [
{
"start": int,
"end": int,
"text": "string",
"document_ids": [
"string"
]
}
],
"finish_reason": string,
"tool_calls": [
{
"name": string,
"parameters": {
"parameter name": string
}
}
],
{
"meta": {
"api_version": {
"version": string
},
"billed_units": {
"input_tokens": int,
"output_tokens": int
}
}
}
```
+ **response\$1id**: identificador único para completar el chat.
+ **text**: respuesta del modelo a la entrada de un mensaje de chat.
+ **generation\$1id**: identificador único para completar el chat, que se utiliza con el punto de conexión Feedback en la plataforma de Cohere.
+ **citations**: conjunto de citas en línea y metadatos asociados a la respuesta generada. Contiene los siguientes campos:
+ **start**: índice en el que comienza la cita, empezando por 0.
+ **final**: índice tras el que termina la cita, empezando por 0.
+ **text**: texto al que pertenece la cita.
+ **document\$1ids**: matriz de identificadores de documentos que corresponden a los documentos que se citan en el texto.
+ **prompt**: petición completa enviada al modelo. Especifique el campo `return_prompt` para devolverlo.
+ **finish\$1reason**: motivo por el que el modelo ha dejado de generar resultados. Puede ser una de los siguientes:
+ **complete**: la finalización ha alcanzado el token del final de la generación. Asegúrese de que este sea el motivo de finalización para obtener el mejor rendimiento.
+ **error\$1toxic**: no se ha podido completar la generación debido a nuestros filtros de contenido.
+ **error\$1limit**: no se ha podido completar la generación porque se ha alcanzado el límite de contexto del modelo.
+ **error**: no se ha podido completar la generación debido a un error.
+ **user\$1cancel**: no se ha podido completar la generación porque el usuario la ha detenido.
+ **max\$1tokens**: no se ha podido completar la generación porque el usuario ha especificado un límite `max_tokens` en la solicitud y se ha alcanzado dicho límite. Es posible que no se obtenga el mejor rendimiento.
+ **tool\$1calls**: lista de las herramientas adecuadas para las llamadas. Solo se devuelve si se especifica el campo de entrada `tools`.
Para obtener más información, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) en la documentación de Cohere.
**sugerencia**
Le recomendamos que utilice la API Converse para integrar el uso de la herramienta en la aplicación. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
A continuación, se muestra un ejemplo de JSON para el campo `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta**: datos de uso de la API (solo existen para la transmisión).
+ `api_version`: versión de la API. La versión está en el campo `version`.
+ `billed_units`: unidades facturadas. Los valores posibles son los siguientes:
+ `input_tokens`: número de tokens de entrada que se ha facturado.
+ `output_tokens`: número de tokens de salida que se ha facturado.
------
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *Cohere Command R*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Cohere Command R model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere Command R model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info(
"Successfully generated text with Cohere Command R model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-r-v1:0'
chat_history = [
{"role": "USER", "message": "What is an interesting new role in AI if I don't have an ML background?"},
{"role": "CHATBOT", "message": "You could explore being a prompt engineer!"}
]
message = "What are some skills I should have?"
try:
body = json.dumps({
"message": message,
"chat_history": chat_history,
"max_tokens": 2000,
"temperature": 0.6,
"p": 0.5,
"k": 250
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
response_chat_history = response_body.get('chat_history')
print('Chat history\n------------')
for response_message in response_chat_history:
if 'message' in response_message:
print(f"Role: {response_message['role']}")
print(f"Message: {response_message['message']}\n")
print("Generated text\n--------------")
print(f"Stop reason: {response_body['finish_reason']}")
print(f"Response text: \n{response_body['text']}")
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 text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos de DeepSeek
DeepSeek[Los modelos R1 y V3.1 están text-to-text disponibles para su uso en la inferencia a través de la API Invoke ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) y la API Converse (Converse y). [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
Cuando realiza llamadas de inferencia con modelos de DeepSeek, debe incluir una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos de DeepSeek compatibles con Amazon Bedrock, consulte [DeepSeek prompt guide](https://api-docs.deepseek.com/guides/reasoning_model.html).
**nota**
No puedes eliminar las solicitudes de acceso de los modelos Amazon Titan, Amazon Nova, DeepSeek -R1, Mistral AI, Meta Llama 3 Instruct y Meta Llama 4. Para evitar que los usuarios hagan llamadas de inferencia a estos modelos, utilice una política de IAM y especifique el ID del modelo. Para obtener más información, consulte [Denegación de acceso para la inferencia de modelos fundacionales](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference .html).
Para obtener una calidad de respuesta óptimaDeepSeek-R1, limite el `max_tokens` parámetro a 8.192 fichas o menos. Si bien la API acepta hasta 32 768 tokens, la calidad de la respuesta se degrada significativamente por encima de los 8 192 tokens. [Esto se alinea con las capacidades de razonamiento del modelo, tal como se describen en la guía de razonamiento por inferencia.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html)
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de DeepSeek. Utilice esta información para realizar llamadas de inferencia a los DeepSeek modelos con la operación. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de DeepSeek.
Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Como este modelo se invoca mediante la inferencia entre regiones, tendrá que utilizar el [ID del perfil de inferencia](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) como ID del modelo. Por ejemplo, para EE. UU., utilice `us.deepseek.r1-v1:0`.
+ Nombre del modelo: DeepSeek-R1
+ Modelos de texto
Para obtener más información sobre cómo usar DeepSeek modelos con APIs, consulte [DeepSeekModelos](https://deepseek.com/).
**Solicitud y respuesta de DeepSeek**
**Cuerpo de la solicitud**
DeepSeektiene los siguientes parámetros de inferencia para una llamada de inferencia de finalización de texto.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_tokens": int,
"stop": string array
}
```
**Campos:**
+ **prompt** (cadena): entrada de texto obligatoria para la petición.
+ **temperature** (float): valor numérico menor o igual que 1.
+ **top\$1p** (float): valor numérico menor o igual que 1.
+ **max\$1tokens**: (int) Se utilizan fichas, de un mínimo de 1 a un máximo de 8.192 fichas para una calidad óptima. Si bien la API acepta hasta 32 768 tokens, la calidad de la respuesta se degrada significativamente por encima de los 8 192 tokens.
+ **stop** (matriz de cadenas): máximo de 10 elementos.
**Cuerpo de respuesta**
DeepSeek tiene los siguientes parámetros de inferencia para realizar una llamada de inferencia de Text Completion. Este ejemplo es una finalización de texto de DeepSeek que no devuelve un bloque de razonamiento de contenido.
```
{
"choices": [
{
"text": string,
"stop_reason": string
}
]
}
```
**Campos:**
+ **stop\$1reason** (cadena): motivo por el que la respuesta ha dejado de generar texto. Un valor de `stop` o `length`.
+ **stop** (cadena): el modelo ha terminado de generar texto para la petición de entrada.
+ **length** (cadena): la longitud de los tokens del texto generado supera el valor de `max_tokens` en la llamada a `InvokeModel` (o `InvokeModelWithResponseStream`, si está transmitiendo la salida). La respuesta se trunca en `max_tokens`. Aumente el valor de `max_tokens` e intente realizar la solicitud de nuevo.
**Código de ejemplo**
En este ejemplo se muestra cómo llamar al modelo DeepSeek-R1.
```
# Use the API to send a text message to DeepSeek-R1.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Región de AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the cross Region inference profile ID for DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in DeepSeek-R1's instruction format.
formatted_prompt = f"""
<｜begin▁of▁sentence｜><｜User｜>{prompt}<｜Assistant｜>\n
"""
body = json.dumps({
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
"top_p": 0.9,
})
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=body)
# Read the response body.
model_response = json.loads(response["body"].read())
# Extract choices.
choices = model_response["choices"]
# Print choices.
for index, choice in enumerate(choices):
print(f"Choice {index + 1}\n----------")
print(f"Text:\n{choice['text']}\n")
print(f"Stop reason: {choice['stop_reason']}\n")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
**Converse**
Cuerpo de la solicitud: use este ejemplo de cuerpo de solicitud para llamar a la API Converse.
```
{
"modelId": string, # us.deepseek.r1-v1:0
"system": [
{
"text": string
}
],
"messages": [
{
"role": string,
"content": [
{
"text": string
}
]
}
],
"inferenceConfig": {
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": string array
},
"guardrailConfig": {
"guardrailIdentifier":"string",
"guardrailVersion": "string",
"trace": "string"
}
}
```
**Campos:**
+ **system**: (opcional) es la petición del sistema para la solicitud.
+ **messages**: (obligatorio) son los mensajes de entrada.
+ **role**: es el rol del turno de conversación. Los valores válidos son `user` y `assistant`.
+ **content** (obligatorio): el contenido del turno de conversación como una matriz de objetos. Cada objeto contiene un campo de tipo, en el que puede especificar uno de los siguientes valores:
+ **text** (obligatorio): si especifica este tipo, debe incluir un campo de texto y especificar la petición de texto como su valor.
+ **inferenceConfig**
+ **temperature** (opcional): valores: mínimo = 0, máximo = 1.
+ **topP** (opcional): valores: mínimo = 0, máximo = 1.
+ **maxTokens** (opcional): el número máximo de tokens que se generarán antes de detenerse. Valores: mínimo = 0, máximo = 32 768.
+ **stopSequences** (opcional): secuencias de texto personalizado que harán que el modelo deje de generar un salida. Máximo = 10 elementos.
Cuerpo de la respuesta: use este ejemplo de cuerpo de solicitud para llamar a la API Converse.
```
{
"message": {
"role" : "assistant",
"content": [
{
"text": string
},
{
"reasoningContent": {
"reasoningText": string
}
}
],
},
"stopReason": string,
"usage": {
"inputTokens": int,
"outputTokens": int,
"totalTokens": int
}
"metrics": {
"latencyMs": int
}
}
```
**Campos:**
+ **message**: la respuesta devuelta por el modelo.
+ **role**: es el rol conversacional del mensaje generado. Este valor siempre es `assistant`.
+ **content**: el contenido generado por el modelo, que se devuelve como una matriz. Existen dos tipos de contenido:
+ **text**: el contenido de texto de la respuesta.
+ **reasoningContent** (opcional): el contenido de razonamiento de la respuesta del modelo.
+ **reasoningText**: el texto de razonamiento de la respuesta del modelo.
+ **stopReason**: el motivo por el que el modelo ha dejado de generar la respuesta.
+ **end\$1turn**: el turno del modelo alcanzó un punto de parada.
+ **max\$1tokens**: el texto generado ha superado el valor del campo de entrada `maxTokens` o ha superado el número máximo de tokens que admite el modelo.
Código de ejemplo: este es un ejemplo de cómo DeepSeek hacer una llamada a la ConverseAPI.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with DeepSeek-R1 (on demand).
"""
import logging
import boto3
from botocore.client import Config
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
max_tokens = 4096
# Base inference parameters to use.
inference_config = {
"temperature": temperature,
"maxTokens": max_tokens,
}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
)
# 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 DeepSeek-R1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "us.deepseek.r1-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:
# Configure timeout for long responses if needed
custom_config = Config(connect_timeout=840, read_timeout=840)
bedrock_client = boto3.client(service_name='bedrock-runtime', config=custom_config)
# 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']
# Remove reasoning content from the response
output_contents = []
for content in output_message["content"]:
if content.get("reasoningContent"):
continue
else:
output_contents.append(content)
output_message["content"] = output_contents
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']:
if content.get("text"):
print(f"Text: {content['text']}")
if content.get("reasoningContent"):
reasoning_content = content['reasoningContent']
reasoning_text = reasoning_content.get('reasoningText', {})
print()
print(f"Reasoning Text: {reasoning_text.get('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()
```
# Modelos de Luma AI
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos Luma AI. Utilice esta información para realizar llamadas de inferencia a los modelos de Luma AI con la operación. [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html) En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos Luma AI. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo.
+ ID del modelo: luma.ray-v 2:0
+ Nombre del modelo: Luma Ray 2
+ Modelo de texto a vídeo
Los modelos Luma AI procesan las solicitudes del modelo de forma asíncrona mediante el Async, que incluye, y. APIs [StartAsyncInvoke[GetAsyncInvoke[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
El modelo Luma AI procesa las peticiones mediante los siguientes pasos.
+ El usuario solicita el modelo mediante. [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
+ Espere hasta que InvokeJob termine. Puede usar `GetAsyncInvoke` o `ListAsyncInvokes` para comprobar el estado de finalización del trabajo.
+ La salida del modelo se colocará en el bucket de Amazon S3 de salida especificado.
Para obtener más información sobre el uso de los modelos Luma AI con APIs, consulte [Generación de vídeo](https://docs.lumalabs.ai/docs/video-generation).
Llamada de inferencia de Luma AI.
```
POST /async-invoke HTTP/1.1
Content-type: application/json
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "your input text here",
"aspect_ratio": "16:9",
"loop": false,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Campos**
+ **prompt** (cadena): el contenido necesario en el vídeo de salida (1 <= longitud <= 5000 caracteres).
+ **aspect\$1ratio** (enumeración): la relación de aspecto del vídeo de salida ("1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21").
+ **loop** (booleano): si se debe reproducir en bucle el vídeo de salida.
+ **duration** (enumeración): la duración del vídeo de salida (“5 s”, “9 s”).
+ **resolution** (enumeración): la resolución del vídeo de salida ("540p", "720p").
El MP4 archivo se almacenará en el bucket de Amazon S3 tal y como se configuró en la respuesta.
## Text-to-Video Generación
Genere vídeos a partir de peticiones de texto utilizando el modelo Luma Ray 2. El modelo admite varias opciones de personalización, como la relación de aspecto, la duración, la resolución y la reproducción en bucle.
** Text-to-VideoSolicitud básica**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Avanzado Text-to-Video con opciones**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit",
"aspect_ratio": "16:9",
"loop": true,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
** Text-to-VideoEjemplo adicional**
Ejemplo con parámetros de resolución y duración.
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "a car",
"resolution": "720p",
"duration": "5s"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
## Image-to-Video Generación
Transforma imágenes estáticas en vídeos dinámicos proporcionando fotogramas clave. Puede especificar los fotogramas iniciales, los fotogramas finales o ambos para controlar el proceso de generación de vídeo.
**Básico Image-to-Video con Start Frame**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
}
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Image-to-Video con marcos inicial y final**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
},
"frame1": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
},
"loop": false,
"aspect_ratio": "16:9"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Parámetros adicionales para Image-to-Video**
+ **fotogramas clave**: (objeto) Defina los fotogramas clave de inicio (fotograma 0) y and/or final (fotograma 1)
+ **frame0**: imagen de fotograma clave inicial
+ **frame1**: imagen del fotograma clave final
+ **type**: debe ser "image"
+ **source**: origen de la imagen
## Resolución de problemas
Problemas comunes y soluciones al trabajar con los modelos Luma AI:
+ **Estado del trabajo “con error”**: compruebe que su bucket de S3 tenga los permisos de escritura adecuados y que el bucket esté en la misma región que su servicio Bedrock.
+ **Errores de acceso a la URL de la imagen**: asegúrese de que la imagen URLs sea de acceso público y utilice HTTPS. Las imágenes deben estar en los formatos admitidos (JPEG o PNG).
+ **Errores de parámetros no válidos**: compruebe que los valores de la relación de aspecto coincidan con las opciones admitidas ("1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21") y que la duración sea "5 s" o "9 s".
+ **Problemas de tiempo de espera agotado**: utilice `GetAsyncInvoke` para comprobar el estado del trabajo en lugar de esperar de forma sincrónica. La generación del vídeo puede tardar varios minutos.
+ **Errores en la longitud de la peticiones**: mantenga las peticiones entre 1 y 5000 caracteres. Se rechazarán las peticiones más largas.
## Notas sobre el rendimiento
Consideraciones importantes sobre el rendimiento y las limitaciones del modelo Luma AI:
+ **Tiempo de procesamiento**: la generación de vídeo suele tardar de dos a cinco minutos para los vídeos de cinco segundos y de cuatro a ocho minutos para los vídeos de nueve segundos, según la complejidad.
+ **Requisitos de imagen**: las imágenes de entrada deben ser de alta calidad con una resolución mínima de 512 x 512 píxeles. El tamaño máximo de imagen admitido es 4096 x 4096 píxeles.
+ **Tamaño del vídeo de salida**: los vídeos generados oscilan entre 5 y 50 MB en función de la duración, la resolución y la complejidad del contenido.
+ **Límites de velocidad**: las llamadas a la API asíncronas están sujetas a las cuotas de servicio. Supervise el uso y solicite un aumento de cuota si es necesario.
+ **Almacenamiento en S3**: asegúrese de que haya suficiente capacidad de almacenamiento en S3 para reproducir vídeos y tenga en cuenta las políticas de ciclo de vida para optimizar los costos.
## Documentación relacionada
Para obtener información adicional y servicios relacionados:
+ **Configuración de Amazon S3**: [Creación de buckets de S3](https://docs.aws.amazon.com/s3/latest/userguide/creating-buckets-s3.html) y [políticas de buckets](https://docs.aws.amazon.com/s3/latest/userguide/bucket-policies.html) para el almacenamiento de salida.
+ **Operaciones de API asíncronas**: [StartAsyncInvoke[GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html), y referencia de [ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)API.
+ **Cuotas de servicio**: [Cuotas para Amazon Bedrock](quotas.md) para solicitudes de límites de servicio y aumento de la cuota de Bedrock.
+ **Prácticas recomendadas de procesamiento de vídeo**: [Envío de solicitudes y generación de respuestas con inferencia de modelos](inference.md) para obtener orientación general sobre la inferencia de modelos.
+ **Documentación de Luma AI**: [Luma Labs Video Generation Documentation](https://docs.lumalabs.ai/docs/video-generation) para conocer las capacidades detalladas del modelo y las características avanzadas.
# Modelos de Meta Llama
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de Meta Llama. Utilice esta información para realizar llamadas de inferencia a los modelos de Meta Llama con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de Meta Llama. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para comprobar si la API Converse es compatible con un modelo de Meta Llama específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos de Meta Llama, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos de Meta Llama, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos de Meta Llama, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando realiza llamadas de inferencia con modelos de Meta Llama, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones a Meta Llama, consulte la [guía de ingeniería de peticiones de Meta Llama](https://ai.meta.com/llama/get-started/#prompting).
**nota**
Los modelos Llama 3.2 Instruct y Llama 3.3 Instruct utilizan geovallas. Esto significa que estos modelos no se pueden utilizar fuera de las regiones de AWS disponibles para los modelos que figuran en la tabla de regiones.
En esta sección se proporciona información sobre el uso de los siguientes modelos de Meta.
+ Llama 3 Instruct
+ Llama 3.1 Instruct
+ Llama 3.2 Instruct
+ Llama 3.3 Instruct
+ Llama 4 Instruct
**Topics**
+ [Solicitud y respuesta](#model-parameters-meta-request-response)
+ [Código de ejemplo](#api-inference-examples-meta-llama)
## Solicitud y respuesta
El cuerpo de la solicitud se pasa en el campo `body` de una solicitud a [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).
**nota**
No puede usar las operaciones [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) o [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html) (streaming) con Llama 4 Instruct.
------
#### [ Request ]
Los modelos Llama 3 Instruct, Llama 3.1 Instruct, Llama 3.2 Instruct y Llama 4 Instruct tienen los siguientes parámetros de inferencia.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_gen_len": int
}
```
NOTA: Los modelos Llama 3.2 y versiones posteriores añaden `images` a la estructura de solicitudes, que es una lista de cadenas. Ejemplo:: `images: Optional[List[str]]`
Los siguientes parámetros son obligatorios:
+ **prompt**: (obligatorio) es el mensaje que desea pasar al modelo. Para obtener resultados óptimos, formatee la conversación con la siguiente plantilla.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Plantilla de ejemplo con petición del sistema**
El siguiente es un ejemplo de petición que incluye una petición del sistema.
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
You are a helpful AI assistant for travel tips and recommendations<|eot_id|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Ejemplo de conversación de varios turnos**
A continuación, se muestra un ejemplo de petición de una conversación de varios turnos.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
The capital of France is Paris!<|eot_id|><|start_header_id|>user<|end_header_id|>
What is the weather like in Paris?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Plantilla de ejemplo con petición del sistema**
Para obtener más información, consulte [Meta Llama 3](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3).
Los siguientes parámetros son opcionales:
+ **temperature**: utilice un valor bajo para reducir la asignación al azar de la respuesta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-meta.html)
+ **top\$1p**: utilice un valor bajo para ignorar las opciones menos probables. Configúrelo en 0 o 1,0 para deshabilitarlo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-meta.html)
+ **max\$1gen\$1len**: especifique la cantidad máxima de tokens a usar en la respuesta generada. El modelo trunca la respuesta una vez que el texto generado excede `max_gen_len`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-meta.html)
------
#### [ Response ]
El modelo Llama 3 Instruct devuelve los siguientes campos para realizar una llamada de inferencia de finalización de texto.
```
{
"generation": "\n\n",
"prompt_token_count": int,
"generation_token_count": int,
"stop_reason" : string
}
```
A continuación, se proporciona más información sobre cada campo.
+ **generation**: es el texto generado.
+ **prompt\$1token\$1count**: es el número de tokens en la petición.
+ **generation\$1token\$1count**: es el número de tokens en el texto generado.
+ **stop\$1reason**: motivo por el que la respuesta ha dejado de generar texto. Los valores posibles son los siguientes:
+ **detener**: el modelo ha terminado de generar texto para la solicitud de entrada.
+ **longitud**: la longitud de los símbolos del texto generado supera el valor de `max_gen_len` en la llamada a `InvokeModel` (`InvokeModelWithResponseStream`, si está transmitiendo la salida). La respuesta se trunca en tokens `max_gen_len`. Considere la posibilidad de aumentar el valor de `max_gen_len` y volver a intentarlo.
------
## Código de ejemplo
En este ejemplo se muestra cómo llamar al modelo *Llama 3 Instruct*.
```
# Use the native inference API to send a text message to Meta Llama 3.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Región de AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 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["generation"]
print(response_text)
```
En este ejemplo se muestra cómo controlar la longitud de generación mediante modelos Llama 3 Instruct. Para obtener respuestas o resúmenes detallados, ajuste ‘max\$1gen\$1len’ e incluya instrucciones específicas en la petición.
# Modelos de Mistral AI
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de Mistral AI. Utilice esta información para realizar llamadas de inferencia a los modelos de Mistral AI con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de Mistral AI. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para comprobar si la API Converse es compatible con un modelo de Mistral AI específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos de Mistral AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos de Mistral AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos de Mistral AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando realiza llamadas de inferencia con modelos de Mistral AI, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones a Mistral AI, consulte la [guía de ingeniería de peticiones de Mistral AI](https://docs.mistral.ai/guides/prompting_capabilities/).
**Topics**
+ [Finalización de texto de Mistral AI](model-parameters-mistral-text-completion.md)
+ [Finalización de chats de Mistral AI](model-parameters-mistral-chat-completion.md)
+ [Parámetros e inferencia de Mistral AI Large (24.07)](model-parameters-mistral-large-2407.md)
+ [Parámetros e inferencia de Pixtral Large (25.02)](model-parameters-mistral-pixtral-large.md)
# Finalización de texto de Mistral AI
La API de finalización de texto de Mistral AI le permite generar texto con un modelo de Mistral AI.
Puede realizar solicitudes de inferencia a modelos Mistral AI con [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) (transmisión).
Los modelos de Mistral AI están disponibles con la [licencia de Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obtener más información sobre el uso de modelos de Mistral AI, consulte la [documentación de Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatibles](#mistral--text-completion-supported-models)
+ [Solicitud y respuesta](#model-parameters-mistral-text-completion-request-response)
+ [Ejemplo de código](#api-inference-examples-mistral-text-completion)
## Modelos compatibles
Puede utilizar los siguientes modelos de Mistral AI.
+ Mistral 7B Instruct
+ Mixtral 8X7B Instruct
+ Mistral Large
+ Mistral Small
Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
## Solicitud y respuesta
------
#### [ Request ]
Los modelos de Mistral AI tienen los siguientes parámetros de inferencia.
```
{
"prompt": string,
"max_tokens" : int,
"stop" : [string],
"temperature": float,
"top_p": float,
"top_k": int
}
```
Los siguientes parámetros son obligatorios.
+ **prompt**: (obligatorio) es la petición que desea pasar al modelo, tal y como se muestra en el siguiente ejemplo.
```
[INST] What is your favourite condiment? [/INST]
```
En el siguiente ejemplo se muestra cómo dar formato a una petición de varios turnos.
```
[INST] What is your favourite condiment? [/INST]
Well, I'm quite partial to a good squeeze of fresh lemon juice.
It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!
[INST] Do you have mayonnaise recipes? [/INST]
```
El texto del rol de usuario está dentro de los tokens `[INST]...[/INST]` y el texto exterior corresponde al rol de asistente. El principio y el final de una cadena se representan mediante los tokens `` (principio de la cadena) y `` (final de la cadena). Para obtener información sobre cómo enviar una petición de chat en el formato correcto, consulte [Chat template](https://docs.mistral.ai/models/#chat-template) en la documentación de Mistral AI.
Los siguientes son parámetros opcionales.
+ **max\$1tokens**: especifique la cantidad máxima de tokens para usar en la respuesta generada. El modelo trunca la respuesta una vez que el texto generado excede `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **stop**: lista de secuencias de parada que, si las genera el modelo, impiden que este genere más resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **temperature**: controla la asignación al azar de las predicciones realizadas por el modelo. Para obtener más información, consulte [Influencia sobre la generación de respuestas con parámetros de inferencia](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1p**: controla la diversidad de texto que genera el modelo al establecer el porcentaje de candidatos más probables que considera el modelo 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).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1k**: es el número 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).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
------
#### [ Response ]
La respuesta `body` de una llamada a `InvokeModel` es la siguiente:
```
{
"outputs": [
{
"text": string,
"stop_reason": string
}
]
}
```
La respuesta `body` tiene los siguientes campos posibles:
+ **outputs**: lista de las salidas del modelo. Cada salida incluye los siguientes campos.
+ **text**: texto que ha generado el modelo.
+ **stop\$1reason**: motivo por el que la respuesta ha dejado de generar texto. Los valores posibles son los siguientes:
+ **stop**: el modelo ha terminado de generar texto para la solicitud de entrada. El modelo se detiene porque ya no genera más contenido o si el modelo genera una de las secuencias de parada que se han definido en el parámetro de solicitud `stop`.
+ **length**: la longitud de los tokens del texto generado supera el valor de `max_tokens` en la llamada a `InvokeModel` (`InvokeModelWithResponseStream`, si está transmitiendo la salida). La respuesta se trunca en tokens `max_tokens`.
------
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo Mistral 7B Instruct.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Mistral AI model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Mistral AI model.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
JSON: The response from the model.
"""
logger.info("Generating text with Mistral AI model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info("Successfully generated text with Mistral AI model %s", model_id)
return response
def main():
"""
Entrypoint for Mistral AI example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
model_id = 'mistral.mistral-7b-instruct-v0:2'
prompt = """[INST] In Bash, how do I list all text files in the current directory
(excluding subdirectories) that have been modified in the last month? [/INST]"""
body = json.dumps({
"prompt": prompt,
"max_tokens": 400,
"temperature": 0.7,
"top_p": 0.7,
"top_k": 50
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
outputs = response_body.get('outputs')
for index, output in enumerate(outputs):
print(f"Output {index + 1}\n----------")
print(f"Text:\n{output['text']}\n")
print(f"Stop reason: {output['stop_reason']}\n")
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 text with Mistral AI model {model_id}.")
if __name__ == "__main__":
main()
```
# Finalización de chats de Mistral AI
La API de finalización de chats de Mistral AI permite crear aplicaciones conversacionales.
**sugerencia**
Puede usar la API de finalización de chats de Mistral AI con las operaciones de inferencia básicas ([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)). Sin embargo, le recomendamos que utilice la API Converse para implementar mensajes en su aplicación. La API Converse proporciona un conjunto unificado de parámetros que funcionan en todos los modelos que admiten mensajes. Para obtener más información, consulte [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md).
Los modelos de Mistral AI están disponibles con la [licencia de Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obtener más información sobre el uso de modelos de Mistral AI, consulte la [documentación de Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatibles](#mistral-supported-models-chat-completion)
+ [Solicitud y respuesta](#model-parameters-mistral-chat-completion-request-response)
## Modelos compatibles
Puede utilizar los siguientes modelos de Mistral AI.
+ Mistral Large
Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
## Solicitud y respuesta
------
#### [ Request ]
Los modelos de Mistral AI tienen los siguientes parámetros de inferencia.
```
{
"messages": [
{
"role": "system"|"user"|"assistant",
"content": str
},
{
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": str,
"function": {
"name": str,
"arguments": str
}
}
]
},
{
"role": "tool",
"tool_call_id": str,
"content": str
}
],
"tools": [
{
"type": "function",
"function": {
"name": str,
"description": str,
"parameters": dict
}
}
],
"tool_choice": "auto"|"any"|"none",
"max_tokens": int,
"top_p": float,
"temperature": float
}
```
Los siguientes parámetros son obligatorios.
+ **messages**: (obligatorio) son los mensajes que desea pasar al modelo.
+ **role**: es el rol para el mensaje. Los valores válidos son:
+ **system**: establece el comportamiento y el contexto del modelo en la conversación.
+ **user**: es el mensaje del usuario que se envía al modelo.
+ **assistant**: es la respuesta del modelo.
+ **content**: es el contenido del mensaje.
```
[
{
"role": "user",
"content": "What is the most popular song on WZPZ?"
}
]
```
Para pasar el resultado de una herramienta, use JSON con los siguientes campos.
+ **role**: es el rol para el mensaje. El valor debe ser `tool`.
+ **tool\$1call\$1id**: es el ID de la solicitud de la herramienta. El ID se obtiene de los campos `tool_calls` de la respuesta de la solicitud anterior.
+ **content**: es el resultado de la herramienta.
El siguiente ejemplo es el resultado de una herramienta que obtiene la canción más popular de una emisora de radio.
```
{
"role": "tool",
"tool_call_id": "v6RMMiRlT7ygYkT4uULjtg",
"content": "{\"song\": \"Elemental Hotel\", \"artist\": \"8 Storey Hike\"}"
}
```
Los siguientes son parámetros opcionales.
+ **tools**: definiciones de las herramientas que puede utilizar el modelo.
Si incluye `tools` en su solicitud, es posible que el modelo devuelva un campo `tool_calls` en el mensaje que represente el uso de esas herramientas por parte del modelo. A continuación, puede ejecutar esas herramientas con la entrada de herramientas generada por el modelo y, si lo desea, devolver los resultados al modelo mediante bloques de contenido `tool_result`.
El siguiente ejemplo es de una herramienta que obtiene la canción más popular de una emisora de radio.
```
[
{
"type": "function",
"function": {
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameters": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
}
]
```
+ **tool\$1choice**: especifica cómo se llama a las funciones. Si se establece en `none`, el modelo no llamará a ninguna función y, en su lugar, generará un mensaje. Si se establece en `auto`, el modelo puede elegir entre generar un mensaje o llamar a una función. Si se establece en `any`, el modelo se ve obligado a llamar a una función.
+ **max\$1tokens**: especifique la cantidad máxima de tokens para usar en la respuesta generada. El modelo trunca la respuesta una vez que el texto generado excede `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **temperature**: controla la asignación al azar de las predicciones realizadas por el modelo. Para obtener más información, consulte [Influencia sobre la generación de respuestas con parámetros de inferencia](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **top\$1p**: controla la diversidad de texto que genera el modelo al establecer el porcentaje de candidatos más probables que considera el modelo 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).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
------
#### [ Response ]
La respuesta `body` de una llamada a `InvokeModel` es la siguiente:
```
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": str,
"tool_calls": [...]
},
"stop_reason": "stop"|"length"|"tool_calls"
}
]
}
```
La respuesta `body` tiene los siguientes campos posibles:
+ **choices**: es la salida del modelo.
+ **index**: es el índice del mensaje.
+ **message**: es el mensaje del modelo.
+ **role**: es el rol para el mensaje.
+ **content**: es el contenido del mensaje.
+ **tool\$1calls**: si el valor de `stop_reason` es `tool_calls`, este campo contiene una lista de solicitudes de herramientas que el modelo quiere que ejecute.
+ **id**: es el ID de la solicitud de herramienta.
+ **function**: es la función que solicita el modelo.
+ **name**: es el nombre de la función.
+ **arguments**: son los argumentos que se pasan a la herramienta
El siguiente ejemplo es de una solicitud a una herramienta que obtiene la canción más popular de una emisora de radio.
```
[
{
"id": "v6RMMiRlT7ygYkT4uULjtg",
"function": {
"name": "top_song",
"arguments": "{\"sign\": \"WZPZ\"}"
}
}
]
```
+ **stop\$1reason**: motivo por el que la respuesta ha dejado de generar texto. Los valores posibles son los siguientes:
+ **stop**: el modelo ha terminado de generar texto para la solicitud de entrada. El modelo se detiene porque ya no genera más contenido o si el modelo genera una de las secuencias de parada que se han definido en el parámetro de solicitud `stop`.
+ **length**: la longitud de los tokens del texto generado supera el valor de `max_tokens`. La respuesta se trunca en tokens `max_tokens`.
+ **tool\$1calls**: el modelo le solicita que ejecute una herramienta.
------
# Parámetros e inferencia de Mistral AI Large (24.07)
La API de finalización de chats de Mistral AI permite crear aplicaciones conversacionales. Con este modelo también puede utilizar la API Converse de Amazon Bedrock. Puede utilizar herramientas para realizar llamadas a funciones.
**sugerencia**
Puede usar la API de finalización de chats de Mistral AI con las operaciones de inferencia básicas ([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)). Sin embargo, le recomendamos que utilice la API Converse para implementar mensajes en su aplicación. La API Converse proporciona un conjunto unificado de parámetros que funcionan en todos los modelos que admiten mensajes. Para obtener más información, consulte [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md).
Los modelos de Mistral AI están disponibles con la [licencia de Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obtener más información sobre el uso de modelos de Mistral AI, consulte la [documentación de Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatibles](#mistral-supported-models-chat-completion)
+ [Ejemplos de solicitud y respuesta](#model-parameters-mistral-large-2407-request-response)
## Modelos compatibles
Puede utilizar los siguientes modelos de Mistral AI con los ejemplos de código de esta página.
+ Mistral Large 2 (24.07)
Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
## Ejemplos de solicitud y respuesta
------
#### [ Request ]
Ejemplo de modelo de invocación de Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model(
modelId='mistral.mistral-large-2407-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ Converse ]
Ejemplo de Converse de Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.converse(
modelId='mistral.mistral-large-2407-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Ejemplo de invoke\$1model\$1with\$1response\$1stream de Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model_with_response_stream(
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French cheese?"}],
}),
"modelId":"mistral.mistral-large-2407-v1:0"
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Ejemplo de converse\$1stream de Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"messages": [{
"role": "user","content": [{"text": "What is the best French cheese? "}]
}],
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.converse_stream(**mistral_params)
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")
```
------
#### [ JSON Output ]
Ejemplo de salida JSON de Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Ejemplo de herramientas de Mistral AI Large (24.07).
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Parámetros e inferencia de Pixtral Large (25.02)
Pixtral Large 25.02 es un modelo multimodal de 124 B de parámetros que combina la comprensión de state-of-the-art imágenes con potentes capacidades de procesamiento de texto. AWS es el primer proveedor de servicios en la nube que ofrece Pixtral Large (25.02) como un modelo totalmente gestionado y sin servidor. Este modelo ofrece un rendimiento de primera clase al realizar tareas de análisis de documentos, interpretación de gráficos y comprensión de imágenes naturales, al tiempo que mantiene las capacidades de texto avanzadas de Mistral Large 2.
Con una ventana de contexto de 128 K, Pixtral Large 25.02 alcanza el best-in-class rendimiento en puntos de referencia clave, como DocVQA y. MathVista VQAv2 El modelo cuenta con compatibilidad multilingüe integral en muchos idiomas y está entrenado en más de 80 lenguajes de programación. Las capacidades clave incluyen el razonamiento matemático avanzado, la invocación de funciones nativas, la generación de salidas JSON y una sólida adherencia al contexto para las aplicaciones RAG.
La API de finalización de chats de Mistral AI permite crear aplicaciones conversacionales. Con este modelo también puede utilizar la API Converse de Amazon Bedrock. Puede utilizar herramientas para realizar llamadas a funciones.
**sugerencia**
Puedes usar la API para completar el Mistral AI chat con las operaciones de inferencia básicas (o). [InvokeModel[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Sin embargo, le recomendamos que utilice la API Converse para implementar mensajes en su aplicación. La API Converse proporciona un conjunto unificado de parámetros que funcionan en todos los modelos que admiten mensajes. Para obtener más información, consulte [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md).
El modelo Mistral AI Pixtral Large está disponible bajo la [Licencia de Mistral Research](https://mistral.ai/licenses/MRL-0.1.md). Para obtener más información sobre el uso de modelos de Mistral AI, consulte la [documentación de Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatibles](#mistral-supported-models-chat-completion)
+ [Ejemplos de solicitud y respuesta](#model-parameters-pixtral-large-2502-request-response)
## Modelos compatibles
Puede utilizar los siguientes modelos de Mistral AI con los ejemplos de código de esta página.
+ Pixtral Large (25.02)
Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
## Ejemplos de solicitud y respuesta
------
#### [ Request ]
Ejemplo de modelo de invocación de Pixtral Large 2 (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
print(json.dumps(json.loads(response.get('body').read()), indent=4))
```
------
#### [ Converse ]
Ejemplo de Converse de Pixtral Large 2 (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
print(json.dumps(response.get('output'), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Ejemplo de invoke\$1model\$1with\$1response\$1stream de Pixtral Large 2 (25-02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model_with_response_stream(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Ejemplo de converse\$1stream de Pixtral Large 2 (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse_stream(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
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")
```
------
#### [ JSON Output ]
Ejemplo de salida JSON de Pixtral Large 2 (25.02).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Ejemplo de herramientas de Pixtral Large 2 (25.02).
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Modelos de OpenAI
OpenAI ofrece los siguientes modelos de ponderación abierta:
+ [https://huggingface.co/openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b): un modelo más pequeño optimizado para una latencia más baja y para casos de uso locales o especializados.
+ [https://huggingface.co/openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b): un modelo más grande optimizado para casos de uso de producción y de uso general o de alto razonamiento.
En la siguiente tabla se resume la información de estos modelos:
| Información | gpt-oss-20b | gpt-oss-120b |
| --- | --- | --- |
| Fecha de publicación | 5 de agosto de 2025 | 5 de agosto de 2025 |
| ID del modelo | openai.gpt-oss-20b-1:0 | openai.gpt-oss-120b-1:0 |
| ID de producto | N/A | N/A |
| Modalidades de entrada admitidas | Texto | Texto |
| Modalidades de salida admitidas | Texto | Texto |
| Ventana de contexto | 128 000 | 128.000 |
Los modelos de OpenAI admiten las siguientes características:
+ [Invocación del modelo](inference.md) con las siguientes operaciones:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
+ [API Chat completions de OpenAI](inference-chat-completions.md)
+ [Inferencia por lotes](batch-inference.md) con [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html).
+ Aplicación de [barreras de protección](guardrails.md) mediante el uso de encabezados en las operaciones de invocación del modelo.
**Topics**
+ [Cuerpo de la solicitud OpenAI](#model-parameters-openai-request)
+ [Cuerpo de la respuesta de OpenAI](#model-parameters-openai-response)
+ [Ejemplo de uso de modelos de OpenAI](#model-parameters-openai-use)
## Cuerpo de la solicitud OpenAI
Para obtener información sobre los parámetros del cuerpo de la solicitud y sus descripciones, consulte [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) en la documentación de OpenAI.
Utilice los campos del cuerpo de la solicitud de las siguientes maneras:
+ En una [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)solicitud de finalización de OpenAI chat, incluya los campos en el cuerpo de la solicitud.
+ En una solicitud [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), haga lo siguiente:
+ Asigne el elemento `messages` como se indica a continuación:
+ Para cada mensaje cuya función sea`developer`, agrega la `content` a [SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)en la `system` matriz.
+ Para cada mensaje cuya función sea `user` o`assistant`, añada la `content` a a [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)en el `content` campo y especifique la `role` en el `role` campo de un [mensaje](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) de la `messages` matriz.
+ Asigne los valores de los siguientes campos a los campos correspondientes del objeto `inferenceConfig`:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-openai.html)
+ Incluya todos los demás campos en el objeto `additionalModelRequestFields`.
**Consideraciones al crear el cuerpo de la solicitud**
+ Los modelos de OpenAI solo admiten la entrada y salida de texto.
+ El valor del campo `model` debe coincidir con el del encabezado. Puede omitir este campo para que se rellene automáticamente con el mismo valor que el encabezado.
+ El valor del campo `stream` debe coincidir con la operación de API que utilice. Puede omitir este campo para que se rellene automáticamente con el valor correcto.
+ Si lo usa [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), el `stream` valor debe ser`false`.
## Cuerpo de la respuesta de OpenAI
El cuerpo de la respuesta de los modelos de OpenAI se ajusta al objeto de finalización del chat devuelto por OpenAI. Para obtener más información acerca de los campos de respuesta, consulte [The chat completion object](https://platform.openai.com/docs/api-reference/chat/object) en la documentación de OpenAI.
**nota**
Si usa `InvokeModel`, el razonamiento del modelo, rodeado por las etiquetas ``, precede al contenido textual de la respuesta.
## Ejemplo de uso de modelos de OpenAI
En esta sección se proporcionan algunos ejemplos de cómo utilizar los modelos de OpenAI.
### Requisitos previos
Antes de probar estos ejemplos, asegúrese de haber satisfecho los requisitos previos:
+ **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.
**nota**
Si utiliza la API Chat completions de OpenAI, solo puede autenticarse con una clave de API de Amazon Bedrock.
+ **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. Debe usar un punto de conexión asociado a una región compatible con el modelo utilizado en el ejemplo.
+ **Acceso al modelo**: solicite el acceso a un modelo de OpenAI. Para obtener más información, consulte [Administre el acceso a los modelos mediante el SDK y la CLI](model-access.md#model-access-modify).
+ **(Si el ejemplo usa un SDK) Instale el SDK**: después de la instalación, configure las credenciales predeterminadas y una AWS región predeterminada. Si no configura las credenciales predeterminadas o una región, tendrá que especificarlas de forma explícita en los ejemplos de código correspondientes. Para obtener más información sobre los proveedores de credenciales estandarizados, consulte los proveedores de [credenciales estandarizados AWS SDKs y Herramientas](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
**nota**
Si usa el SDK de OpenAI, solo puede autenticarse con una clave de API de Amazon Bedrock y debe configurar explícitamente el punto de conexión de Amazon Bedrock.
Amplíe la sección para ver el ejemplo que desee:
### Create chat completion de OpenAI
Para ver ejemplos del uso de la API Create chat completion de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ OpenAI SDK (Python) ]
El siguiente script de Python llama a la API Create chat completion con el SDK de Python de OpenAI:
```
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 using curl ]
Puede ejecutar el siguiente comando en una ventana de terminal para llamar a la API Create chat completion mediante curl:
```
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!"
}
]
}'
```
------
### InvokeModel
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ Python ]
```
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Model ID
model_id = 'openai.gpt-oss-20b-1:0'
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"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?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
# Make the InvokeModel request
response = client.invoke_model(
modelId=model_id,
body=json.dumps(native_request)
)
# Parse and print the message for each choice in the chat completion
response_body = json.loads(response['body'].read().decode('utf-8'))
for choice in response_body['choices']:
print(choice['message']['content'])
```
------
### Converse
Cuando utiliza la API unificada [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), debe asignar los campos de Create chat completion de OpenAI a su campo correspondiente en el cuerpo de la solicitud de Converse.
Por ejemplo, compare el siguiente cuerpo de la solicitud de finalización del chat con el cuerpo de la solicitud de Converse correspondiente:
------
#### [ Create chat completion request body ]
```
{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"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?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7
}
```
------
#### [ Converse request body ]
```
{
"messages": [
{
"role": "user",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
],
"system": [
{
"text": "You are a helpful assistant."
}
],
"inferenceConfig": {
"maxTokens": 150,
"temperature": 0.7
}
}
```
------
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ Python ]
```
# Use the Conversation API to send a text message to Anthropic Claude.
import boto3
from botocore.exceptions import ClientError
# Initialize the Bedrock Runtime client
client = boto3.client("bedrock-runtime")
# Set the model ID
model_id = "openai.gpt-oss-20b-1:0"
# Set up messages and system message
messages = [
{
"role": "assistant",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
]
system = [
{
"text": "You are a helpful assistant."
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=messages,
system=system,
inferenceConfig={
"maxTokens": 150,
"temperature": 0.7,
"topP": 0.9
},
)
# Extract and print the response text.
for content_block in response["output"]["message"]["content"]:
print(content_block)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
------
### Barandillas con InvokeModel
Aplique una barrera de protección al ejecutar la invocación del modelo especificando el ID de la barrera de protección, la versión y si desea habilitar o no el rastreo de la barrera de protección en el encabezado de una solicitud de invocación de modelos.
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import json
# Initiate the Amazon Bedrock Runtime client
bedrock_runtime = boto3.client("bedrock-runtime")
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values from your guardrail
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"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?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
try:
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=json.dumps(native_request),
guardrailIdentifier=guardrail_id,
guardrailVersion=guardrail_version,
trace='ENABLED',
)
response_body = json.loads(response.get('body').read())
print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
print(json.dumps(response_body, indent=2))
except ClientError as err:
print("RequestId = " + err.response['ResponseMetadata']['RequestId'])
raise err
```
------
### Barreras de protección con finalizaciones de chat de OpenAI
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);
```
------
### Inferencia en lotes
La [inferencia en lotes](batch-inference.md) le permite ejecutar la inferencia de modelos de forma asíncrona con varias peticiones. Para ejecutar la inferencia en lotes con un modelo de OpenAI, haga lo siguiente:
1. Cree un archivo JSONL y rellénelo con al menos el número mínimo de objetos JSON, cada uno de ellos separado por una nueva línea. Cada objeto `modelInput` debe ajustarse al formato del cuerpo de la solicitud de [create chat completion de OpenAI](https://platform.openai.com/docs/api-reference/chat/create). A continuación, se muestra un ejemplo de las dos primeras líneas de un archivo JSONL que contiene los cuerpos de las solicitudes de OpenAI.
```
{
"recordId": "RECORD1",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Can you generate a question with a factual answer?"
}
],
"max_completion_tokens": 1000
}
}
{
"recordId": "RECORD2",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 1000
}
}
...
```
**nota**
El campo `model` es opcional porque el servicio de inferencia en lotes lo insertará automáticamente en función del encabezado si lo omite.
Compruebe que el archivo JSONL cumpla las cuotas de inferencia en lotes que se indican en [Formateo y carga de los datos de la inferencia por lotes](batch-inference-data.md).
1. Cargue el archivo en un bucket de Amazon S3.
1. Envíe una [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html)solicitud con un [punto final del plano de control de Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-cp) con el bucket S3 del paso anterior especificado en el `inputDataConfig` campo y el OpenAI modelo especificado en el `modelId` campo.
Para ver un ejemplo end-to-end de código, consulte[Ejemplos de código de inferencia en lotes](batch-inference-example.md). Sustitúyalo con las configuraciones adecuadas para los modelos de OpenAI.
# Modelos de Stability AI
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de Stability AI. Utilice esta información para realizar llamadas de inferencia a los modelos de IA de estabilidad con la [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operación. En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de Stability AI. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para saber si la API Converse es compatible con un modelo de Stability AI específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para conocer las modalidades que admiten los modelos de Stability AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para saber qué características de Amazon Bedrock son compatibles con los modelos de Stability AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué AWS regiones están disponibles los modelos de IA de estabilidad, consulte[Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando se realizan llamadas de inferencia con modelos de Stability AI, se incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones específicas de Stability AI, consulte [Stability AI prompt engineering guide](https://platform.stability.ai/docs/getting-started).
## Modelos y servicios de imágenes compatibles
Amazon Bedrock admite los siguientes modelos y servicios de imágenes de Stability AI:
**nota**
La compatibilidad con los demás modelos de Stability AI se va a retirar.
| Modelo | Casos de uso | Ejemplo |
| --- | --- | --- |
| [Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Una marca de lujo utiliza Stable Image Ultra para crear imágenes impactantes de su última colección para publicaciones en revistas, con el fin de garantizar un acabado de primer nivel que refleje sus altos estándares. |
| [Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un equipo de desarrollo de juegos utiliza SD3 .5 Large para crear texturas ambientales y conceptos de personajes detallados, lo que acelera su proceso creativo. |
| [Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un minorista en línea utiliza Stable Image Core para generar rápidamente imágenes de productos para los recién llegados, lo que le permite publicar artículos más rápido y conservar su catálogo up-to-date. |
| [Servicios de imágenes de Stability AI](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Una empresa de medios utiliza la búsqueda y el cambio de color, la transferencia de estilo y la eliminación del fondo para generar variaciones de imágenes para una campaña publicitaria. |
**Topics**
+ [Modelos y servicios de imágenes compatibles](#supported-stability-models)
+ [Solicitud y respuesta de Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md)
+ [Stability.ai Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md)
+ [Solicitud y respuesta de Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Servicios de imágenes de Stability AI](stable-image-services.md)
# Solicitud y respuesta de Stable Image Ultra
El cuerpo de la solicitud se pasa al `body` campo de una solicitud de [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operación.
**Campo del cuerpo de la solicitud de invocación del modelo**
Cuando realices una InvokeModel llamada con un modelo Stable Image Ultra, rellena el campo del cuerpo con un objeto JSON parecido al que se muestra a continuación.
+ **prompt**: (cadena) lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campo del cuerpo de respuestas a la invocación del modelo**
Cuando realice una llamada a `InvokeModel` con un modelo Stable Image Ultra, la respuesta será similar a la siguiente.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Una respuesta con un motivo de finalización que no sea `null` tendrá el siguiente aspecto:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (cadena) lista de semillas utilizadas para generar imágenes para el modelo.
+ **finish\$1reasons**: enumeración que indica si la solicitud se ha filtrado o no. `null` indica que la solicitud se ha realizado correctamente. Valores posibles actuales: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: lista de imágenes generadas en formato de cadena base64.
Para obtener más información, consulta [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generación](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
El modelo Stable Image Ultra de Stability.ai tiene los siguientes parámetros de inferencia para una llamada de text-to-image inferencia.
+ **prompt**: (cadena) lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionales**
+ **aspect\$1ratio**: (cadena) controla la relación de aspecto de la imagen generada. Este parámetro solo es válido para text-to-image las solicitudes. El valor predeterminado es 1:1. Enumeración: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **modo**: establecido en text-to-image. Predeterminado: text-to-image. Enum: `text-to-image`.
+ **output\$1format**: especifica el formato de la imagen de salida. Formatos compatibles: JPEG y PNG. Dimensiones admitidas: altura de 640 a 1536 px, anchura de 640 a 1536 px.
+ **seed**: (número) valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: del 0 al 4294967295.
+ **negative\$1prompt**: palabras clave de lo que no desea ver en la imagen de salida. Máximo: 10 000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
#### [ Image to image ]
El modelo Stable Image Ultra de Stability.ai tiene los siguientes parámetros de inferencia para una llamada de image-to-image inferencia.
+ **prompt**: (cadena) lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionales**
+ **image** (cadena): la imagen Base64 que se utilizará como punto de partida para la generación. Formatos compatibles: JPEG, PNG, WebP.
+ **strength** (número): la influencia que tiene el parámetro image sobre la imagen generada. Las imágenes con valores de intensidad más bajos se parecerán más a la imagen original. Intervalo: de 0,0 a 1,0. Valor predeterminado: 0,35.
+ **aspect\$1ratio**: (cadena) controla la relación de aspecto de la imagen generada. Este parámetro solo es válido para text-to-image las solicitudes. El valor predeterminado es 1:1. Enumeración: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica el formato de la imagen de salida. Formatos compatibles: JPEG y PNG. Dimensiones admitidas: altura de 640 a 1536 px, anchura de 640 a 1536 px.
+ **seed**: (número) valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: del 0 al 4294967295.
+ **negative\$1prompt**: palabras clave de lo que no desea ver en la imagen de salida. Máximo: 10 000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability.ai Stable Diffusion 3.5 Large
El modelo Stable Diffusion 3.5 Large utiliza 8 mil millones de parámetros y admite una salida de resolución de 1 megapíxel para su text-to-image image-to-image generación.
El cuerpo de la solicitud se pasa en el `body` campo de una solicitud a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo del cuerpo de la solicitud de invocación del modelo**
Cuando realices una InvokeModel llamada con un modelo Stable Diffusion 3.5 Large, rellena el campo del cuerpo con un objeto JSON parecido al que se muestra a continuación.
+ **prompt** (cadena): descripción textual de la imagen de salida deseada. Máximo 10 000 caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Campo del cuerpo de respuestas a la invocación del modelo**
Cuando realiza una llamada a `InvokeModel` con un modelo Stable Diffusion 3.5 Large, la respuesta es similar a la siguiente.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Una respuesta con un motivo de finalización que no sea `null` tendrá el siguiente aspecto:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (cadena) lista de semillas utilizadas para generar imágenes para el modelo.
+ **finish\$1reasons**: enumeración que indica si la solicitud se ha filtrado o no. `null` indica que la solicitud se ha realizado correctamente. Valores posibles actuales: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: lista de imágenes generadas en formato de cadena base64.
------
#### [ Text to image ]
El modelo Stability.ai Stable Diffusion 3.5 Large tiene los siguientes parámetros de inferencia para una llamada de text-to-image inferencia.
+ **prompt** (string): descripción textual de la imagen de salida deseada. Máximo 10 000 caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Parámetros opcionales**
+ **aspect\$1ratio** (cadena): controla la relación de aspecto de la imagen generada. Válido solo para solicitudes. text-to-image Enumeración: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. El valor predeterminado es 1:1.
+ **mode** (string) (GenerationMode) - Predeterminado: text-to-image. Enum: image-to-image o. text-to-image Controla si se trata de una image-to-image generación text-to-image o, lo que afecta a los parámetros necesarios:
+ text-to-image solo requiere el parámetro prompt.
+ image-to-image requiere los parámetros de aviso, imagen y intensidad.
+ **semilla** (número): valor para controlar la aleatoriedad en la generación. Intervalo: de 0 a 4294967294. Predeterminado 0 (semilla aleatoria).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (cadena): texto que describe los elementos que se van a excluir de la imagen de salida. Máximo 10 000 caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string): formato de imagen de salida. Enum: jpeg, png, webp. Valor predeterminado: png.
```
import boto3
import json
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
```
------
#### [ Image to image ]
El modelo Stability.ai Stable Diffusion 3.5 Large tiene los siguientes parámetros de inferencia para una llamada de inferencia. image-to-image
+ **prompt** (string): descripción textual de la imagen de salida deseada. Máximo 10 000 caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **imagen** (cadena): imagen de entrada codificada en Base64. Mínimo de 64 píxeles por lado. Formatos compatibles: jpeg, png, webp.
+ **mode** (string) (GenerationMode) - Predeterminado:. text-to-image Enum: image-to-image o. text-to-image Controla si se trata de una image-to-image generación text-to-image o, lo que afecta a los parámetros necesarios:
+ text-to-image solo requiere el parámetro prompt.
+ image-to-image requiere los parámetros de aviso, imagen y intensidad.
+ **fuerza** (número): controla la influencia de la imagen de entrada en la salida. Intervalo del 0 al 1. El valor de 0 conserva la imagen de entrada; el valor de 1 ignora la imagen de entrada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **semilla** (número): valor para controlar la aleatoriedad en la generación. Intervalo: de 0 a 4294967294. Predeterminado 0 (semilla aleatoria).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (cadena): texto que describe los elementos que se van a excluir de la imagen de salida. Máximo 10 000 caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string): formato de imagen de salida. Enum: jpeg, png, webp. Valor predeterminado: png.
```
import boto3
import base64
import json
# Load and encode image
with open('input_image.jpg', 'rb') as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.',
'image': image_base64,
'strength': 0.7
})
)
```
------
# Solicitud y respuesta de Stable Image Core
El cuerpo de la solicitud se pasa en el `body` campo de una solicitud a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo del cuerpo de la solicitud de invocación del modelo**
Cuando realices una InvokeModel llamada con un modelo Stability AI Stable Diffusion Stable Image Core, rellena el campo del cuerpo con un objeto JSON parecido al siguiente.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo del cuerpo de respuestas a la invocación del modelo**
Cuando realizas una InvokeModel llamada con un modelo Stability AI Stable Diffusion Stable Image Core, la respuesta es similar a la siguiente
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (cadena) lista de semillas utilizadas para generar imágenes para el modelo.
+ **finish\$1reasons**: enumeración que indica si la solicitud se ha filtrado o no. `null` indica que la solicitud se ha realizado correctamente. Valores posibles actuales: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: lista de imágenes generadas en formato de cadena base64.
Para obtener más información, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generación](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
El modelo Stable Image Core tiene los siguientes parámetros de inferencia para realizar una llamada de inferencia de texto a imagen.
**text\$1prompts** (obligatorio): una matriz de mensajes de texto que se utilizan en la generación. Cada elemento es un objeto JSON que contiene una petición y una ponderación para la petición.
+ **prompt**: (cadena) lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Campos opcionales**
+ **aspect\$1ratio**: (cadena) controla la relación de aspecto de la imagen generada. Este parámetro solo es válido para text-to-image las solicitudes. El valor predeterminado es 1:1. Enumeración: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica el formato de la imagen de salida. Formatos compatibles: JPEG y PNG. Dimensiones admitidas: altura de 640 a 1536 px, anchura de 640 a 1536 px.
+ **seed**: (número) valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: del 0 al 4294967295.
+ **negative\$1prompt**: palabras clave de lo que no desea ver en la imagen de salida. Máximo: 10 000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.stable-image-core-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Servicios de imágenes de Stability AI
Puede utilizar Stability AI Image Services con Amazon Bedrock para acceder a trece herramientas de edición de imágenes especializadas diseñadas para acelerar los flujos de trabajo creativos profesionales. Con los servicios de imágenes de Stability AI, puede generar imágenes a partir de un boceto, reestructurar y cambiar el estilo de una imagen existente o eliminar y reemplazar los objetos de una imagen.
En esta sección se describe cómo realizar llamadas de inferencia a Stability AI Image Services mediante el. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) En esta sección también se proporcionan ejemplos de código en Python y ejemplos de imágenes antes y después de usar los servicios de imágenes de Stability AI.
Los servicios de imágenes de Stability AI están disponibles en las siguientes categorías:
+ **Edición**: servicios de edición de imágenes basados en IA, que incluyen relleno de zonas con máscaras (relleno generativo) o con palabras. Incluye herramientas para la colocación y publicidad de productos, así como herramientas básicas, como la eliminación de fondos.
+ **Control**: puede utilizar peticiones, mapas y otras guías. Estos servicios aprovechan ControlNets tecnologías similares basadas en modelos Stable Diffusion.
**nota**
Al suscribirse a cualquier servicio de imágenes de IA de Stability, editarlo o controlarlo, se inscribirá automáticamente en los trece servicios de imágenes de IA de Stability disponibles.
**Topics**
+ [Solicitud y respuesta](#model-parameters-stable-image-services-request-response)
+ [Exclusivo](#stable-image-services-upscale)
+ [Edición](#stable-image-services-edit)
+ [Controlar](#stable-image-services-control)
## Solicitud y respuesta
El cuerpo de la solicitud se pasa en el `body` campo de la solicitud a. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
**Campo del cuerpo de la solicitud de invocación del modelo**
Cuando realices una InvokeModel llamada con Stability AI Image Services, rellena el campo del cuerpo con un objeto JSON parecido al que se muestra a continuación.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo del cuerpo de respuestas a la invocación del modelo**
Cuando haces una InvokeModel llamada con Stability AI Image Services, la respuesta es similar a la siguiente
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (cadena) lista de semillas utilizadas para generar imágenes para el modelo.
+ **finish\$1reasons**: enumeración que indica si la solicitud se ha filtrado o no. `null` indica que la solicitud se ha realizado correctamente. Valores posibles actuales: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: lista de imágenes generadas en formato de cadena base64.
Para obtener más información, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 generación](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Exclusivo
En la siguiente sección se describen los exclusivos servicios de imágenes de Stability AI.
### Creative Upscale
Creative Upscale toma imágenes de entre 64 x 64 y 1 megapíxel y las amplía a una resolución de 4K. Este servicio puede aumentar la escala de las imágenes entre 20 y 40 veces y, al mismo tiempo, preservar la calidad y, a menudo, mejorarla. Creative Upscale funciona mejor con imágenes muy degradadas y no es adecuado para fotografías de 1 megapíxel o más, ya que permite realizar una reinvención intensiva.
Creative Upscale tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** ‐ (cadena) La imagen de Base64 que se va a ampliar. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles debe estar comprendido entre 4 096 y 1 048.576 píxeles. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **creatividad** ‐ (número) Indica el grado de creatividad que debe tener el modelo a la hora de escalar una imagen. Los valores más altos harán que se añadan más detalles a la imagen durante la ampliación. Rango entre 0,1 y 0,5. Predeterminado: 0.3
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **style\$1preset**: guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
La siguiente tabla muestra las imágenes de entrada y salida de una operación de Creative Upscale siguiendo el siguiente mensaje: *Esta obra de arte digital onírica captura un pájaro vibrante y caleidoscópico* en una exuberante selva tropical.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Conservador y exclusivo
Conservative Upscale toma imágenes de entre 64 x 64 y 1 megapíxel y las amplía a una resolución de 4K. Este servicio puede aumentar la escala de las imágenes entre 20 y 40 veces y, al mismo tiempo, conservar todos los aspectos. Conservative Upscale minimiza las alteraciones de la imagen y no debe utilizarse para reimaginar una imagen.
Conservative Upscale tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** ‐ (cadena) La imagen de Base64 que se va a escalar. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **creatividad** ‐ (número) Indica qué tan creativo debe ser el modelo al escalar una imagen. Los valores más altos harán que se añadan más detalles a la imagen durante la ampliación. Rango entre 0,1 y 0,5. Predeterminado: 0.35
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de Conservative Upscale que utiliza el siguiente mensaje: *foto de un pollo gigante en un bosque*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### ¡Rápido y exclusivo\$1
Fast Upscale mejora 4 veces la resolución de la imagen mediante la IA predictiva y generativa. Este servicio ligero y rápido es ideal para mejorar la calidad de las imágenes comprimidas, lo que lo hace adecuado para publicaciones en redes sociales y otras aplicaciones.
Fast upscale tiene los siguientes parámetros obligatorios:
+ **image** ‐ (cadena) La imagen de Base64 que se va a escalar. El ancho debe estar comprendido entre 32 y 1.536 píxeles. La altura debe estar entre 32 y 1.536 píxeles. El número total de píxeles debe estar comprendido entre 1.024 y 1.048.576 píxeles. Formatos compatibles: jpeg, png, webp.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
La siguiente tabla muestra las imágenes de entrada y salida de una operación de Fast Upscale.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Edición
En la siguiente sección se describen los servicios de edición de imágenes de Stability AI.
### Relleno de zonas
La característica Relleno de zonas modifica las imágenes de forma inteligente rellenando o sustituyendo áreas específicas por contenido nuevo en función del contenido de la imagen de una máscara.
Relleno de zonas tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 que se va a rellenar. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **style\$1preset** (cadena): guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **mask** (cadena): controla la intensidad del proceso de relleno por píxel, ya sea mediante una segunda imagen (pasada a este parámetro) o mediante el canal alfa del parámetro de imagen.
+ **Pasar una máscara**: la imagen que se pase a este parámetro debe ser una imagen en blanco y negro que represente, en cualquier píxel, la intensidad del relleno en función del grado de oscuridad o claridad del píxel en cuestión. Los píxeles completamente negros representan la ausencia de relleno, mientras que los píxeles completamente blancos representan la intensidad de relleno máxima. En el caso de que la máscara tenga un tamaño diferente al del parámetro de la imagen, se redimensionará automáticamente.
+ **Compatibilidad con el canal alfa**: si no proporciona una máscara explícita, se obtendrá una del canal alfa del parámetro de imagen. Los píxeles transparentes se rellenarán mientras que los opacos se preservarán. En el caso de que se proporcione una imagen con un canal alfa junto con una máscara, la máscara tendrá prioridad.
+ **grow\$1mask**: amplía los bordes de la máscara hacia afuera en todas las direcciones según el número de píxeles especificado. El área expandida alrededor de la máscara se difuminará, lo que puede ayudar a suavizar la transición entre el contenido rellenado y la imagen original. El intervalo está entre 0 y 20. Valor predeterminado: 5. Pruebe este parámetro si observa bordes irregulares o uniones visibles alrededor del contenido rellenado. Tenga en cuenta que un crecimiento excesivo puede oscurecer los detalles finos de la máscara y and/or combinar las regiones enmascaradas cercanas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de relleno de zonas.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Pinta más que
Outpaint inserta contenido adicional en una imagen para rellenar el espacio en cualquier dirección. En comparación con otros intentos automatizados o manuales de ampliar el contenido de una imagen, el servicio Outpaint minimiza los indicios de que la imagen original se ha editado.
Outpaint tiene los siguientes parámetros obligatorios:
+ **image** ‐ (string) La imagen de Base64 que se va a pintar mejor. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
**nota**
Se debe proporcionar al menos una dirección de pintura exterior: (izquierda, derecha, arriba o abajo) con un valor distinto de cero. Para obtener resultados de la mejor calidad, tenga en cuenta la composición y el contenido de la imagen original al elegir las direcciones de pintura exterior.
Los siguientes parámetros son opcionales:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **style\$1preset** (cadena): guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **creatividad** ‐ (número) Indica el grado de creatividad que debe tener el modelo a la hora de pintar una imagen. Los valores más altos harán que se añada más contenido creativo a la imagen durante la pintura exterior. Rango entre 0,1 y 1,0. Valor predeterminado: 0,5.
+ **left** ‐ (entero) El número de píxeles que se van a pintar más en la parte izquierda de la imagen. Debe proporcionarse al menos una dirección de pintura exterior con un valor distinto de cero. Rango de 0 a 2000. Predeterminado 0.
+ **right** ‐ (entero) El número de píxeles que se van a pintar más en el lado derecho de la imagen. Debe proporcionarse al menos una dirección de pintura exterior con un valor distinto de cero. Rango de 0 a 2000. Predeterminado 0.
+ **up** ‐ (entero) El número de píxeles que se van a pintar más en la parte superior de la imagen. Debe proporcionarse al menos una dirección de pintura exterior con un valor distinto de cero. Rango de 0 a 2000. Predeterminado 0.
+ **down** ‐ (entero) El número de píxeles que se van a pintar más en la parte inferior de la imagen. Debe proporcionarse al menos una dirección de pintura exterior con un valor distinto de cero. Rango de 0 a 2000. Predeterminado 0.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
La siguiente tabla muestra las imágenes de entrada y salida de una operación de Outpaint.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Búsqueda y cambio de color
La función Búsqueda y cambio de color le permite cambiar el color de un objeto específico de una imagen mediante una petición. Este servicio es una versión específica de relleno de zonas que no requiere una máscara. Segmentará automáticamente el objeto y lo volverá a colorear con los colores solicitados en la petición.
La característica Búsqueda y cambio de color tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 que se va a cambiar de color. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
+ **select\$1prompt** (cadena): breve descripción de lo que se debe buscar en la imagen. Máximo 10000 caracteres.
Los siguientes parámetros son opcionales:
+ **style\$1preset** (cadena): guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **grow\$1mask**: amplía los bordes de la máscara hacia afuera en todas las direcciones según el número de píxeles especificado. El área expandida alrededor de la máscara se difuminará, lo que puede ayudar a suavizar la transición entre el contenido rellenado y la imagen original. El intervalo está entre 0 y 20. Valor predeterminado: 5. Pruebe este parámetro si observa bordes irregulares o uniones visibles alrededor del contenido rellenado. Tenga en cuenta que un crecimiento excesivo puede oscurecer los detalles finos de la máscara y and/or combinar las regiones enmascaradas cercanas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de búsqueda y cambio de color mediante la siguiente petición: *pink jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Búsqueda y reemplazo
La característica Búsqueda y reemplazado permite utilizar una petición de búsqueda para identificar en un lenguaje sencillo el objeto que se va a reemplazar. El servicio segmentará automáticamente el objeto y lo sustituirá por el objeto solicitado en la petición sin necesidad de utilizar una máscara.
La característica Búsqueda y reemplazo tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 que se va a cambiar de color. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
+ **search\$1prompt** (cadena): breve descripción de lo que se debe rellenar en la imagen. Máximo 10000 caracteres.
Los siguientes parámetros son opcionales:
+ **style\$1preset** (cadena): guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **grow\$1mask**: amplía los bordes de la máscara hacia afuera en todas las direcciones según el número de píxeles especificado. El área expandida alrededor de la máscara se difuminará, lo que puede ayudar a suavizar la transición entre el contenido rellenado y la imagen original. El intervalo está entre 0 y 20. Valor predeterminado: 5. Pruebe este parámetro si observa bordes irregulares o uniones visibles alrededor del contenido rellenado. Tenga en cuenta que un crecimiento excesivo puede oscurecer los detalles finos de la máscara y and/or combinar las regiones enmascaradas cercanas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de búsqueda y reemplazo mediante la siguiente petición: *jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Erase (Borrar)
El borrado permite eliminar elementos no deseados mediante máscaras de imagen y, al mismo tiempo, mantener de forma inteligente la coherencia del fondo.
La característica de borrado tiene los siguientes parámetros obligatorios:
+ **image** (cadena): la imagen en Base64 en la que se va a realizar la operación de borrado. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **mask** (cadena): controla la intensidad del proceso de relleno por píxel, ya sea mediante una segunda imagen (pasada a este parámetro) o mediante el canal alfa del parámetro de imagen.
+ **Pasar una máscara**: la imagen que se pase a este parámetro debe ser una imagen en blanco y negro que represente, en cualquier píxel, la intensidad del relleno en función del grado de oscuridad o claridad del píxel en cuestión. Los píxeles completamente negros representan la ausencia de relleno, mientras que los píxeles completamente blancos representan la intensidad de relleno máxima. En el caso de que la máscara tenga un tamaño diferente al del parámetro de la imagen, se redimensionará automáticamente.
+ **Compatibilidad con el canal alfa**: si no proporciona una máscara explícita, se obtendrá una del canal alfa del parámetro de imagen. Los píxeles transparentes se rellenarán mientras que los opacos se preservarán. En el caso de que se proporcione una imagen con un canal alfa junto con una máscara, la máscara tendrá prioridad.
+ **grow\$1mask**: amplía los bordes de la máscara hacia afuera en todas las direcciones según el número de píxeles especificado. El área expandida alrededor de la máscara se difuminará, lo que puede ayudar a suavizar la transición entre el contenido rellenado y la imagen original. El intervalo está entre 0 y 20. Valor predeterminado: 5. Pruebe este parámetro si observa bordes irregulares o uniones visibles alrededor del contenido rellenado. Tenga en cuenta que un crecimiento excesivo puede oscurecer los detalles finos de la máscara y and/or fusionar las regiones enmascaradas cercanas.
**nota**
Para obtener resultados de borrado óptimos, asegúrese de que la máscara defina con precisión las áreas que se van a quitar. Si no se proporciona una máscara explícita, el servicio utilizará el canal alfa de la imagen de entrada. La máscara tendrá prioridad si se proporcionan ambas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de borrado.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Eliminación del fondo
La característica Eliminación del fondo le permite aislar los sujetos del fondo con precisión.
La característica Eliminación del fondo tiene los siguientes parámetros obligatorios:
+ **image** (cadena): la imagen en Base64 de la que se va a eliminar el fondo. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de eliminación del fondo.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Controlar
En la siguiente sección se describen los servicios de control de imágenes de Stability AI.
### Control de boceto
Actualice los bocetos dibujados a mano para convertirlos en resultados refinados con un control preciso. En el caso de imágenes que no son bocetos, el control de bocetos permite una manipulación detallada del aspecto final al utilizar las líneas de contorno y los bordes de la imagen.
La característica Control de boceto tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 del boceto. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **control\$1strength** (número): cuánta influencia o control tiene la imagen en la generación. Se representa como un valor flotante comprendido entre 0 y 1, donde 0 es la menor influencia y 1 es la máxima influencia. El valor predeterminado es 0,7.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **style\$1preset**: guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una llamada a la característica Control de boceto utilizando la siguiente petición: *una casa con un fondo de montañas y un río que fluye cerca*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Control de estructura
La característica Control de estructura le permite generar imágenes manteniendo la estructura de una imagen de entrada. Esto resulta especialmente útil para escenarios avanzados de creación de contenido, como la recreación de escenas o la representación de personajes a partir de modelos.
La característica Control de estructura tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 del boceto. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **control\$1strength** (número): cuánta influencia o control tiene la imagen en la generación. Se representa como un valor flotante comprendido entre 0 y 1, donde 0 es la menor influencia y 1 es la máxima influencia. El valor predeterminado es 0,7.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **style\$1preset**: guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una operación de control de estructura que utiliza la siguiente petición: *estructura surrealista con chispas generadas por el movimiento que iluminan la escena*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Guía de estilo
La Guía de estilo permite extraer elementos estilísticos de una imagen de entrada y utilizarla para guiar la creación de una imagen de salida en función de la petición. El resultado es una imagen nueva con el mismo estilo que la imagen de entrada.
La Guía de estilo tiene los siguientes parámetros obligatorios:
+ **prompt**: lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul. Mínimo 0 caracteres y máximo 10 000 caracteres.
+ **image** (cadena): la imagen en Base64 del boceto. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **aspect\$1ratio**: (cadena) controla la relación de aspecto de la imagen generada. Este parámetro solo es válido para text-to-image las solicitudes. El valor predeterminado es 1:1. Enumeración: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. El valor predeterminado es 1:1.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **fidelity** (número): cuánto se parece el estilo de la imagen de salida al estilo de la imagen de entrada. Intervalo del 0 al 1. Valor predeterminado: 0,5.
+ **style\$1preset**: guía el modelo de imagen hacia un estilo concreto. Enum: 3d-model, analog-film, anime, cinematic, modeling-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una llamada a Guía de estilo utilizando la siguiente petición: *plano panorámico de una metrópolis moderna*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Transferencia de estilo
La transferencia de estilo permite aplicar características visuales de las imágenes de estilo de referencia a las imágenes de destino. Mientras que el servicio Guía de estilo extrae los elementos estilísticos de una imagen de entrada y los utiliza para guiar la creación de una imagen de salida en función de la petición, Transferencia de estilo transforma específicamente el contenido existente al tiempo que conserva la composición original. Esta herramienta ayuda a crear contenido coherente en varios activos.
Transferencia de estilo tiene los siguientes parámetros obligatorios:
+ **init\$1image** (cadena): una imagen en Base64 que contiene el sujeto al que desea cambiar el estilo. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
+ **style\$1image** (cadena): una imagen en Base64 que contiene el sujeto al que desea cambiar el estilo. Cada lado de la imagen debe tener al menos 64 píxeles. El número total de píxeles no puede superar los 9 437 184 píxeles. La relación de aspecto debe estar entre comprendida entre 1:2.5 y 2.5:1. Formatos compatibles: jpeg, png, webp.
Los siguientes parámetros son opcionales:
+ **prompt**: (cadena) lo que desea ver en la imagen de salida. Una petición descriptiva y fuerte que defina claramente los elementos, los colores y los sujetos permitirá obtener mejores resultados. Para controlar el peso de una palabra determinada, use el formato (word:weight), donde word es la palabra cuyo peso quiere controlar y weight es un valor. Los valores 0 y 1,0 restan énfasis a la palabra y los valores comprendidos entre 1,1 y 2 enfatizan la palabra. Por ejemplo: el cielo era nítido (azul:0,3) y (verde:1,8) representaría un cielo azul y verde, pero más verde que azul.
+ **negative\$1prompt** (cadena): un blurb de texto que describe lo que no desea ver en la imagen de salida. Esta es una característica avanzada. Máximo 10000 caracteres.
+ **seed** (número): un valor específico que se utiliza para determinar la asignación al azar de la generación. (Omita este parámetro o pase 0 para usar una semilla aleatoria). Intervalo: de 0 a 4294967294. Valor predeterminado: 0.
+ **output\$1format** (cadena): indica el tipo de contenido de la imagen generada. Enum: jpeg, png, webp. Valor predeterminado: png.
+ **composition\$1fidelity** (número): cuánto se parece el estilo de la imagen de salida al estilo de la imagen de entrada. El intervalo está entre 0 y 1. Valor predeterminado: 0,9.
+ **style\$1strength** (número): este parámetro, que a veces se denomina “reducción de ruido”, controla la influencia que tiene el parámetro de la imagen sobre la imagen generada. Un valor de 0 generaría una imagen idéntica a la entrada. Un valor de 1 sería como si no hubiera pasado ninguna imagen. El intervalo está entre 0 y 1. Valor predeterminado: 1.
+ **change\$1strength** (número): cuánto debe cambiar la imagen original. El intervalo está entre 0,1 y 1. Valor predeterminado: 0,9.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
style_image = "./content/style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/cat_statue_512x512.jpg"
style_image = "./content/glowbot_style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
En la siguiente tabla se muestran las imágenes de entrada y salida de una llamada a Transferencia de estilo.
| Input | Style (Estilo) | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |
# Modelos de TwelveLabs
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de TwelveLabs. Utilice esta información para realizar llamadas de inferencia a los modelos de TwelveLabs. El TwelveLabs Pegasus 1.2 modelo admite [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operaciones [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(de transmisión). Los TwelveLabs Marengo Embed 3.0 modelos TwelveLabs Marengo Embed 2.7 y apoyan [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)las operaciones. En esta sección también se incluyen ejemplos de código que muestran cómo llamar a los modelos de TwelveLabs. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
TwelveLabs es un proveedor líder de modelos de IA multimodales especializado en la comprensión y el análisis de vídeo. Sus modelos avanzados permiten sofisticadas capacidades de búsqueda de vídeo, análisis y generación de contenido mediante tecnologías de visión state-of-the-art artificial y procesamiento del lenguaje natural.
Amazon Bedrock ofrece tres TwelveLabs modelos:
+ TwelveLabs Pegasus 1.2proporciona una comprensión y un análisis exhaustivos del vídeo.
+ TwelveLabs Marengo Embed 2.7genera incrustaciones de alta calidad para contenido de vídeo, texto, audio e imágenes.
+ TwelveLabs Marengo Embed 3.0es el último modelo de incrustación con prestaciones y prestaciones mejoradas.
Estos modelos le ayudan a crear aplicaciones que procesan, analizan y obtienen información a partir de datos de vídeo a escala.
**TwelveLabs Pegasus 1.2**
Un modelo multimodal que proporciona capacidades integrales de comprensión y análisis de vídeo, incluido el reconocimiento de contenido, la detección de escenas y la comprensión del contexto. El modelo puede analizar el contenido de vídeo y generar descripciones textuales, información y respuestas a preguntas sobre el vídeo.
**TwelveLabs Marengo Embed 2.7**
Un modelo de incrustación multimodal que genera representaciones vectoriales de alta calidad del contenido de vídeo, texto, audio e imágenes para la búsqueda de similitudes, la agrupación en clústeres y otras tareas de machine learning. El modelo admite varias modalidades de entrada y proporciona incrustaciones especializadas optimizadas para diferentes casos de uso.
**TwelveLabs Marengo Embed 3.0**
Un modelo de incrustación multimodal mejorado que amplía las capacidades de Marengo 2.7 al admitir la modalidad de entrada intercalada de texto e imagen. Este modelo genera representaciones vectoriales de alta calidad de contenido de vídeo, texto, audio, imágenes y texto-imagen intercaladas para la búsqueda de similitudes, la agrupación en clústeres y otras tareas de aprendizaje automático.
**Topics**
+ [TwelveLabs Pegasus 1.2](model-parameters-pegasus.md)
+ [TwelveLabs Marengo Embed 2.7](model-parameters-marengo.md)
+ [TwelveLabs Marengo Embed 3.0](model-parameters-marengo-3.md)
# TwelveLabs Pegasus 1.2
El modelo TwelveLabs Pegasus 1.2 proporciona capacidades integrales de comprensión y análisis de vídeo. Puede analizar el contenido de vídeo y generar descripciones textuales, información y respuestas a preguntas sobre el vídeo.
Utilice esta información para realizar llamadas de inferencia a TwelveLabs los modelos con las InvokeModel operaciones InvokeModelWithResponseStream (de transmisión).
+ Proveedor: TwelveLabs
+ Categorías: comprensión del vídeo, análisis de contenido
+ ID de modelo: `twelvelabs.pegasus-1-2-v1:0`
+ Modalidad de entrada: vídeo
+ Modalidad de salida: texto
+ Tamaño máximo del vídeo: vídeo de 1 hora de duración (tamaño de archivo inferior a 2 GB)
## Parámetros de solicitud de TwelveLabs Pegasus 1.2
En la siguiente tabla se describen los parámetros de entrada para el modelo TwelveLabs Pegasus 1.2:
**Parámetros de solicitud de TwelveLabs Pegasus 1.2**
| Campo | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| inputPrompt | string | Sí | Petición para analizar el vídeo. 2000 tokens como máximo |
| temperature | double | No | Temperatura del modelo. Controla la asignación al azar de la salida. Predeterminado: 0,2, mínimo: 0, máximo: 1. |
| responseFormat | Objeto | No | Permite a los usuarios especificar el formato de salida estructurado. Actualmente solo admite json\$1schema. |
| mediaSource | objeto | Sí | Describe el origen del contenido multimedia. Se debe proporcionar base64String o s3Location. |
| mediaSource.base64String | cadena | No | Cadena de bytes codificada en Base64 para el vídeo. Máximo: 25 MB. |
| mediaSource.s3Location.uri | cadena | No | La URI de S3 desde donde se puede descargar el vídeo. Máximo: vídeo de 1 hora de duración (tamaño de archivo inferior a 2 GB) |
| mediaSource.s3Location.bucketOwner | cadena | No | ID de la cuenta de AWS del propietario del bucket. |
| maxOutputTokens | entero | No | El número máximo de tokens que se generarán. Máx.: 4096. |
## Campos de respuesta de TwelveLabs Pegasus 1.2
En la siguiente tabla se describen los campos de salida del modelo TwelveLabs Pegasus 1.2:
**Campos de respuesta de TwelveLabs Pegasus 1.2**
| Campo | Tipo | Description (Descripción) |
| --- | --- | --- |
| message | cadena | Mensaje de salida que contiene el análisis del vídeo realizado por el modelo. |
| finishReason | cadena | Motivo de la parada que describe por qué finalizó la salida. Valores válidos: stop (la API devolvió las finalizaciones completas sin alcanzar ningún límite), length (la generación superó el límite de max\$1tokens). |
## Solicitud y respuesta de TwelveLabs Pegasus 1.2
En los siguientes ejemplos se muestra cómo usar el modelo TwelveLabs Pegasus 1.2 con diferentes orígenes de entrada.
------
#### [ Request ]
En los siguientes ejemplos se muestran los formatos de solicitud del modelo TwelveLabs Pegasus 1.2.
**Uso de vídeo codificado en base64:**
```
{
"inputPrompt": "tell me about the video",
"mediaSource": {
"base64String": ""
},
"temperature": 0
}
```
**Uso de vídeo almacenado en S3:**
```
{
"inputPrompt": "Tell me about this video",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0
}
```
**Uso de formato de salida estructurado:**
```
{
"inputPrompt": "Analyze this video and provide a structured summary",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0.2,
"maxOutputTokens": 2048,
"responseFormat": {
"type": "json_schema",
"json_schema": {
"name": "video_analysis",
"schema": {
"type": "object",
"properties": {
"summary": {"type": "string"},
"key_scenes": {"type": "array", "items": {"type": "string"}},
"duration": {"type": "string"}
},
"required": ["summary", "key_scenes"]
}
}
}
}
```
------
#### [ Response ]
En los siguientes ejemplos se muestran los formatos de respuesta del modelo TwelveLabs Pegasus 1.2.
**Respuesta estándar:**
```
{
"message": "This video shows a person walking through a park during sunset. The scene includes trees, a walking path, and golden lighting from the setting sun. The person appears to be enjoying a peaceful evening stroll.",
"finishReason": "stop"
}
```
**Respuesta con salida estructurada:**
```
{
"message": "{\"summary\": \"A peaceful evening walk through a park at sunset\", \"key_scenes\": [\"Person entering the park\", \"Walking along tree-lined path\", \"Sunset lighting through trees\", \"Person sitting on bench\"], \"duration\": \"Approximately 2 minutes\"}",
"finishReason": "stop"
}
```
**Respuesta cuando se alcanza el máximo de tokens:**
```
{
"message": "This video contains multiple scenes showing various activities. The first scene shows...",
"finishReason": "length"
}
```
------
# TwelveLabs Marengo Embed 2.7
El modelo TwelveLabs Marengo Embed 2.7 genera incrustaciones a partir de entradas de vídeo, texto, audio o imagen. Estas incrustaciones se pueden utilizar para la búsqueda de similitudes, la agrupación en clústeres y otras tareas de machine learning.
+ Proveedor — TwelveLabs
+ ID de modelo: twelvelabs.marengo-embed-2-7-v1:0
El modelo TwelveLabs Marengo Embed 2.7 admite las operaciones de Tiempo de ejecución de Amazon Bedrock que se indican en la siguiente tabla.
+ Para obtener más información sobre los casos de uso para los diferentes métodos de API, consulte [Obtenga información sobre los casos de uso de diferentes métodos de inferencia de modelosDiferentes métodos de inferencia](inference-methods.md).
+ Para obtener más información acerca de los tipos de modelos, consulte [Cómo funciona la inferencia en Amazon BedrockCómo funciona la inferencia](inference-how.md).
+ Para obtener una lista de modelos IDs y ver los modelos y AWS las regiones compatiblesTwelveLabs Marengo Embed 2.7, busque el modelo en la tabla de[Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
+ Para obtener una lista completa del perfil de inferencia IDs, consulte[Regiones y modelos compatibles con los perfiles de inferencia](inference-profiles-support.md). El ID del perfil de inferencia se basa en la AWS región.
****
| Operación de la API | Tipos de modelos compatibles | Modalidades de entrada | Modalidades de salida |
| --- | --- | --- | --- |
| InvokeModel | [Perfiles de inferencia](inference-profiles-support.md) | Texto Image | Incrustación |
| StartAsyncInvoke | [Modelos base](models-supported.md) | Video Audio Image Texto | Incrustación |
**nota**
Utilice `InvokeModel` para generar incrustaciones para la consulta de búsqueda. Utilice `StartAsyncInvoke` para generar incrustaciones de activos a gran escala.
Las siguientes cuotas se aplican a la entrada:
****
| Modalidad de entrada | Máximo |
| --- | --- |
| Texto | 77 fichas |
| Image | 5 MB |
| Vídeo (S3) | 2 GB |
| Audio (S3) | 2 GB |
**nota**
Si define audio o vídeo insertado mediante la codificación base64, asegúrese de que la carga útil del cuerpo de la solicitud no supere la cuota de invocación de modelos de Amazon Bedrock de 25 MB.
**Topics**
+ [Parámetros de solicitud de TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-async-request)
+ [Respuesta de TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-response)
+ [Ejemplos de código de TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-examples)
## Parámetros de solicitud de TwelveLabs Marengo Embed 2.7
Al realizar una solicitud, el campo en el que se especifica la entrada específica del modelo depende del funcionamiento de la API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— En la solicitud`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— En el `modelInput` campo del cuerpo de la solicitud.
El formato de la entrada del modelo depende de la modalidad de entrada:
------
#### [ Text ]
```
{
"inputType": "text",
"inputText": "string",
"textTruncate": "string
}
```
------
#### [ Inline image ]
```
{
"inputType": "image",
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
------
#### [ S3 image ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
}
```
------
#### [ Inline video ]
```
{
"inputType": "video",
"mediaSource": {
"s3Location": {
"base64String": "base64-encoded string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"embeddingOption": "visual-text" | "visual-image" | "audio"
}
```
------
#### [ S3 video ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"minClipSec": int,
"embeddingOption": ["string"]
}
```
------
#### [ Inline audio ]
```
{
"inputType": "audio",
"mediaSource": {
"base64String": "base64-encoded string"
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
#### [ S3 audio ]
```
{
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
Amplíe las siguientes secciones para obtener detalles sobre los parámetros de entrada:
### inputType
Modalidad de incrustación.
+ **Tipo:** cadena
+ **Obligatorio**: sí
+ **Valores válidos**: `video` \$1 `text` \$1 `audio` \$1 `image`
### inputText
Texto que se va a incrustar.
+ **Tipo:** cadena
+ **Obligatorio:** sí (para tipos de entrada compatibles)
+ **Tipos de entrada compatibles:** texto
### textTruncate
Especifica cómo la plataforma trunca el texto.
+ **Tipo:** cadena
+ **Obligatorio**: no
+ **Valores válidos:**
+ `end`: trunca el final del texto.
+ `none`: devuelve un error si el texto supera el límite.
+ **Valor predeterminado:** final
+ **Tipos de entrada compatibles:** texto
### mediaSource
Contiene información sobre el origen del contenido multimedia.
+ **Tipo:** objeto
+ **Obligatorio:** sí (si el tipo es compatible)
+ **Tipos de entrada compatibles:** imagen, vídeo, audio
El formato del objeto `mediaSource` en el cuerpo de la solicitud depende de si el contenido multimedia está definido como una cadena codificada en Base64 o como una ubicación de S3.
+ **Cadena codificada en base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: la cadena codificada en Base64 del contenido multimedia.
+ **Ubicación de S3**: especifique el URI de S3 y el propietario del bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: el URI de S3 que contiene el contenido multimedia.
+ `bucketOwner`— El ID de AWS cuenta del propietario del bucket de S3.
### embeddingOption
Especifica los tipos de incrustaciones que se van a recuperar.
+ **Tipo**: lista
+ **Obligatorio**: no
+ **Valores válidos para los miembros de la lista:**
+ `visual-text`: incrustaciones visuales optimizadas para la búsqueda de texto.
+ `visual-image`: incrustaciones visuales optimizadas para la búsqueda de imágenes.
+ `audio`: incrustaciones del audio en el vídeo.
+ **Valor predeterminado:** ["visual-text", "visual-image", "audio"]
+ **Tipos de entrada compatibles:** vídeo, audio
### startSec
Punto temporal en segundos del clip en el que debe comenzar el procesamiento.
+ **Tipo**: Doble
+ **Obligatorio**: no
+ **Valor mínimo:** 0
+ **Valor predeterminado:** 0
+ **Tipos de entrada compatibles:** vídeo, audio
### lengthSec
El tiempo en segundos, contado desde el punto temporal `startSec`, tras el cual debe detenerse el procesamiento.
+ **Tipo**: Doble
+ **Obligatorio**: no
+ **Valores válidos:** 0: duración del contenido multimedia
+ **Valor predeterminado:** duración del contenido multimedia
+ **Tipos de entrada compatibles:** vídeo, audio
Ejemplo:
+ startSec: 5
+ lengthSec: 20
+ Resultado: el clip se procesa entre las 0:05 y las 0:25 (5 segundos \$1 20 segundos).
### useFixedLengthSec
La duración de cada clip para el que el modelo debe generar una incrustación.
+ **Tipo**: Doble
+ **Obligatorio**: no
+ **Parámetros de valor:** 2 - 10. Debe ser mayor o igual que `minClipSec`.
+ **Valor predeterminado:** depende del tipo de contenido multimedia:
+ **Vídeo:** Dividido dinámicamente por la detección del límite del tiro.
+ **Audio:** dividido en partes iguales con segmentos lo más próximos posible a 10 segundos.
Ejemplos:
+ Un clip de 50 segundos se divide en 5 segmentos de 10 segundos.
+ Un clip de 16 segundos se divide en 2 segmentos de 8 segundos.
+ **Tipos de entrada compatibles:** vídeo, audio
+ **Notas:** Debe ser mayor o igual que `minClipSec`.
### minClipSec
Establece un valor mínimo para cada clip en segundos.
+ **Tipo:** int
+ **Obligatorio**: no
+ **Parámetros de valor:** intervalo: 1-5
+ **Valor predeterminado**: 4
+ **Tipos de entrada compatibles:** vídeo
+ **Notas:** Debe ser menor o igual que `useFixedLengthSec`.
## Respuesta de TwelveLabs Marengo Embed 2.7
La ubicación de las incrustaciones de salida y los metadatos asociados depende del método de invocación:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— En el cuerpo de la respuesta.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— En el segmento S3 definido en el`s3OutputDataConfig`, una vez finalizado el trabajo de invocación asíncrona.
Si hay varios vectores de incrustaciones, la salida es una lista de objetos, cada uno de los cuales contiene un vector y sus metadatos asociados.
El formato del vector de incrustaciones de salida es el siguiente:
```
{
"embedding": ["string"],
"embeddingOption": "visual-text" | "visual-image" | "audio",
"startSec": double,
"endsec": double
}
```
Amplíe las siguientes secciones para obtener detalles sobre los parámetros de respuesta:
### Incrustación
Representación vectorial de la incrustaciones de entrada.
+ **Tipo**: lista de valores double
### embeddingOption
El tipo de incrustaciones.
+ **Tipo:** cadena
+ **Valores posibles:**
+ `visual-text`: incrustaciones visuales optimizadas para la búsqueda de texto.
+ `visual-image`: incrustaciones visuales optimizadas para la búsqueda de imágenes.
+ `audio`: incrustaciones del audio en el vídeo.
+ **Tipos de entrada compatibles:** vídeo
### startSec
El desplazamiento inicial del clip.
+ **Tipo**: Doble
+ **Tipos de entrada compatibles:** vídeo, audio
### endSec
El desplazamiento final del clip, en segundos.
+ **Tipo**: Doble
+ **Tipos de entrada compatibles:** vídeo, audio
## Ejemplos de código de TwelveLabs Marengo Embed 2.7
En esta sección se muestra cómo utilizar el modelo TwelveLabs Marengo Embed 2.7 con diferentes tipos de entrada mediante Python. Los ejemplos muestran cómo definir la entrada específica del modelo y ejecutar las invocaciones del modelo.
**nota**
InvokeModel solo admite la entrada de texto e imagen. Para la entrada de vídeo y audio, utilice StartAsyncInvoke.
Reúna su código con los siguientes pasos:
**1. Defina la entrada específica del modelo**
Defina la entrada específica del modelo en función del tipo de entrada:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "text",
"inputText": "man walking a dog"
}
```
------
#### [ Inline image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"base64String": "example-base64-image"
}
}
```
------
#### [ S3 image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
```
------
#### [ Inline video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"base64String": "base_64_encoded_string_of_video"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ S3 video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"s3Location": {
"uri": "amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ Inline audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"base64String": "base_64_encoded_string_of_audio"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
#### [ S3 audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
**2. Ejecute la invocación del modelo utilizando la entrada del modelo**
A continuación, añada el fragmento de código que corresponda al método de invocación del modelo que prefiera.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://&example-s3-destination-bucket;"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# TwelveLabs Marengo Embed 3.0
El TwelveLabs Marengo Embed 3.0 modelo genera incrustaciones mejoradas a partir de entradas de vídeo, texto, audio o imagen. Esta última versión ofrece un rendimiento y una precisión mejorados en la búsqueda de similitudes, la agrupación en clústeres y otras tareas de aprendizaje automático.
+ Proveedor: TwelveLabs
+ ID de modelo: twelvelabs.marengo-embed-3-0-v1:0
Marengo Embed 3.0 ofrece varias mejoras clave:
+ **Capacidad de procesamiento de vídeo ampliada**: procese hasta 4 horas de contenido de vídeo y audio. Los archivos pueden ocupar hasta 6 GB, el doble de la capacidad de las versiones anteriores. Esto lo hace ideal para analizar eventos deportivos completos, vídeos de entrenamiento prolongados y producciones cinematográficas completas.
+ **Análisis deportivo mejorado**: el modelo ofrece mejoras significativas. Proporciona una mejor comprensión de la dinámica del juego, los movimientos de los jugadores y la detección de eventos.
+ **Soporte multilingüe global**: capacidades lingüísticas ampliadas de 12 a 36 idiomas. Esto permite a las organizaciones globales crear sistemas unificados de búsqueda y recuperación que funcionan sin problemas en diversas regiones y mercados.
+ **Precisión de búsqueda multimodal**: combine imágenes y texto descriptivo en una sola solicitud de incrustación. Esto combina la similitud visual con la comprensión semántica para ofrecer resultados de búsqueda más precisos y contextualmente relevantes.
+ **Dimensión de incrustación reducida**: se ha reducido de 1024 a 512, lo que puede ayudar a reducir los costes de almacenamiento.
El modelo TwelveLabs Marengo Embed 3.0 admite las operaciones de Tiempo de ejecución de Amazon Bedrock que se indican en la siguiente tabla.
+ Para obtener más información sobre los casos de uso para los diferentes métodos de API, consulte [Obtenga información sobre los casos de uso de diferentes métodos de inferencia de modelosDiferentes métodos de inferencia](inference-methods.md).
+ Para obtener más información acerca de los tipos de modelos, consulte [Cómo funciona la inferencia en Amazon BedrockCómo funciona la inferencia](inference-how.md).
+ Para obtener una lista de modelos IDs y ver los modelos y AWS las regiones compatiblesTwelveLabs Marengo Embed 3.0, busque el modelo en la tabla que aparece en. [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md)
+ Para obtener una lista completa del perfil de inferencia IDs, consulte[Regiones y modelos compatibles con los perfiles de inferencia](inference-profiles-support.md). El ID del perfil de inferencia se basa en la AWS región.
****
| Operación de la API | Tipos de modelos compatibles | Modalidades de entrada | Modalidades de salida |
| --- | --- | --- | --- |
| InvokeModel | US East (Virginia del Norte): [modelos base y perfiles](models-supported.md) de [inferencia](inference-profiles-support.md) Europa (Irlanda) [— Perfiles de inferencia](inference-profiles-support.md) Asia-Pacífico (Seúl): modelos [básicos](models-supported.md) | Texto Image **Nota:** También se admiten textos e imágenes intercalados. | Incrustación |
| StartAsyncInvoke | [Modelos base](models-supported.md) | Video Audio Image Texto **Nota:** También se admiten textos e imágenes intercalados. | Incrustación |
**nota**
Utilice `InvokeModel` para generar incrustaciones para la consulta de búsqueda. Utilice `StartAsyncInvoke` para generar incrustaciones de activos a gran escala.
Las siguientes cuotas se aplican a la entrada:
****
| Modalidad de entrada | Máximo |
| --- | --- |
| Texto | 500 fichas |
| Image | 5 MB por imagen |
| Vídeo (S3) | 6 GB, 4 horas de duración |
| Audio (S3) | 6 GB, 4 horas de duración |
**nota**
Si define audio o vídeo insertado mediante la codificación base64, asegúrese de que la carga útil del cuerpo de la solicitud no supere la cuota de invocación de modelos de Amazon Bedrock de 25 MB.
**Topics**
+ [Parámetros de solicitud de TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-async-request)
+ [Respuesta de TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-response)
+ [Ejemplos de código de TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-examples)
## Parámetros de solicitud de TwelveLabs Marengo Embed 3.0
Al realizar una solicitud, el campo en el que se especifica la entrada específica del modelo depende del funcionamiento de la API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— En la solicitud`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— En el `modelInput` campo del cuerpo de la solicitud.
El formato de la entrada del modelo depende de la modalidad de entrada:
------
#### [ Text ]
```
{
"inputType": "text",
"text": {
"inputText": "string"
}
}
```
------
#### [ Image ]
```
{
"inputType": "image",
"image": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
{
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
{
"inputType": "audio",
"audio": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/audio/a.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"audio",
"transcription"
], // optional, default=both
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
}
}
```
------
#### [ Video ]
```
{
"inputType": "video",
"video": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video/clip.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "dynamic", // dynamic OR fixed, exactly one
"dynamic": {
"minDurationSec": 4
}
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"visual",
"audio",
"transcription"
], // optional, default=all
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
},
"inferenceId": "some inference id"
}
```
------
Amplíe las siguientes secciones para obtener detalles sobre los parámetros de entrada:
### inputType
Modalidad de incrustación.
+ **Tipo:** cadena
+ **Obligatorio**: sí
+ **Valores válidos**: `text` \$1 `image` \$1 `text_image` \$1 `audio` \$1 `video`
### inputText
Texto que se va a incrustar.
+ **Tipo:** cadena
+ **Obligatorio:** sí (para tipos de entrada compatibles)
+ **Tipos de entrada compatibles:** texto
### mediaSource
Contiene información sobre el origen del contenido multimedia.
+ **Tipo:** objeto
+ **Obligatorio:** sí (si el tipo es compatible)
+ **Tipos de entrada compatibles:** imagen, vídeo, audio
El formato del objeto `mediaSource` en el cuerpo de la solicitud depende de si el contenido multimedia está definido como una cadena codificada en Base64 o como una ubicación de S3.
+ **Cadena codificada en base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: la cadena codificada en Base64 del contenido multimedia.
+ **Ubicación de S3**: especifique el URI de S3 y el propietario del bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: el URI de S3 que contiene el contenido multimedia.
+ `bucketOwner`— El ID de AWS cuenta del propietario del bucket de S3.
### embeddingOption
Especifica los tipos de incrustaciones que se van a recuperar.
+ **Tipo**: lista
+ **Obligatorio**: no
+ **Valores válidos para los miembros de la lista:**
+ `visual`— Inserciones visuales del vídeo.
+ `audio`: incrustaciones del audio en el vídeo.
+ `transcription`— Incrustaciones del texto transcrito.
+ **Valor predeterminado:**
+ Vídeo: ["visual», «audio», «transcripción"]
+ Audio: ["audio», «transcripción"]
+ **Tipos de entrada compatibles:** vídeo, audio
### Incrustar Scope
Especifica el alcance de las incrustaciones que se van a recuperar.
+ **Tipo**: lista
+ **Obligatorio**: no
+ **Valores válidos para los miembros de la lista:**
+ `clip`— Devuelve las incrustaciones de cada clip.
+ `asset`— Devuelve las incrustaciones de todo el activo.
+ **Tipos de entrada compatibles:** vídeo, audio
### startSec
Punto temporal en segundos del clip en el que debe comenzar el procesamiento.
+ **Tipo**: Doble
+ **Obligatorio**: no
+ **Valor mínimo:** 0
+ **Valor predeterminado**: 0
+ **Tipos de entrada compatibles:** vídeo, audio
### endSec
Punto temporal en segundos en el que debe finalizar el procesamiento.
+ **Tipo**: Doble
+ **Obligatorio**: no
+ **Valor mínimo:** StartSec \$1 longitud del segmento
+ **Valor máximo:** duración del contenido multimedia
+ **Valor predeterminado:** duración del contenido multimedia
+ **Tipos de entrada compatibles:** vídeo, audio
### Segmentación
Define cómo se divide el contenido multimedia en segmentos para la generación de elementos incrustados.
+ **Tipo:** objeto
+ **Obligatorio**: no
+ **Tipos de entrada compatibles:** vídeo, audio
El objeto de segmentación contiene un `method` campo y parámetros específicos del método:
+ `method`— El método de segmentación que se va a utilizar. Valores válidos: `dynamic` \$1 `fixed`
+ `dynamic`— En el caso del vídeo, utiliza la detección de límites de disparo para dividir el contenido de forma dinámica. Contiene:
+ `minDurationSec`— Duración mínima de cada segmento en segundos. Tipo: número entero. Rango: 1-5. Predeterminado: 4.
+ `fixed`— Divide el contenido en segmentos de igual duración. Contiene:
+ `durationSec`— Duración de cada segmento en segundos. Tipo: número entero. Rango: 1-10. Predeterminado: 6.
**Comportamiento predeterminado**:
+ Vídeo: utiliza segmentación dinámica con detección de límites de disparo.
+ Audio: utiliza segmentación fija. El contenido se divide lo más uniformemente posible con segmentos cercanos a los 10 segundos.
### ID de inferencia
Identificador único para la solicitud de inferencia.
+ **Tipo:** cadena
+ **Obligatorio**: no
## Respuesta de TwelveLabs Marengo Embed 3.0
La ubicación de las incrustaciones de salida y los metadatos asociados depende del método de invocación:
+ InvokeModel — En el cuerpo de la respuesta.
+ StartAsyncInvoke — En el segmento S3 definido en`s3OutputDataConfig`, una vez finalizado el trabajo de invocación asíncrona.
Si hay varios vectores de incrustaciones, la salida es una lista de objetos, cada uno de los cuales contiene un vector y sus metadatos asociados.
El formato del vector de incrustaciones de salida es el siguiente:
```
{
"data": {
"embedding": [
0.111, 0.234, ...
],
"embeddingOption": ["visual", "audio", "transcription" (for video input) | "audio", "transcription" (for audio input)],
"embeddingScope": ["asset" | "clip"],
"startSec": 0,
"endSec": 4.2
}
}
```
Las incrustaciones se devuelven como una matriz de elementos flotantes.
El lugar donde veas esta respuesta depende del método de API que hayas utilizado:
+ InvokeModel — Aparece en el cuerpo de la respuesta.
+ StartAsyncInvoke — Aparece en la ubicación S3 que especificó en la solicitud. La respuesta devuelve un`invocationArn`. Puede usar esto para obtener metadatos sobre la invocación asíncrona. Esto incluye el estado y la ubicación de S3 donde se escriben los resultados.
Amplíe las siguientes secciones para obtener detalles sobre los parámetros de respuesta:
### Incrustación
Representación vectorial de la incrustaciones de entrada.
+ **Tipo**: lista de valores double
### embeddingOption
El tipo de incrustaciones.
+ **Tipo:** cadena
+ **Valores posibles:**
+ visual: incrustaciones visuales del vídeo.
+ audio: incrustaciones del audio en el vídeo.
+ transcripción: incrustaciones del texto transcrito.
+ **Tipos de entrada compatibles:** vídeo, audio
### Incrustar Scope
Especifica el alcance de las incrustaciones que se van a recuperar.
+ **Tipo:** cadena
Puede incluir uno o más de los siguientes valores:
+ clip: devuelve las incrustaciones de cada clip.
+ activo: devuelve las incrustaciones de todo el activo.
### startSec
El desplazamiento inicial del clip.
+ **Tipo**: Doble
+ **Tipos de entrada compatibles:** vídeo, audio
### endSec
El desfase final del clip. No se aplica a las incrustaciones de texto, imagen o texto\$1imagen.
+ **Tipo**: Doble
+ **Tipos de entrada compatibles:** vídeo, audio
## Ejemplos de código de TwelveLabs Marengo Embed 3.0
En esta sección se muestra cómo utilizar el modelo TwelveLabs Marengo Embed 3.0 con diferentes tipos de entrada mediante Python. Los ejemplos muestran cómo definir la entrada específica del modelo y cómo ejecutar las invocaciones del modelo.
**nota**
InvokeModel admite texto, imagen y texto con entrada de imagen intercalada. Para la entrada de vídeo y audio, utilice. StartAsyncInvoke
Reúna su código con los siguientes pasos:
**1. Defina la entrada específica del modelo**
Defina la entrada específica del modelo en función del tipo de entrada:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text",
"text": {
"inputText": "man walking a dog"
}
}
```
------
#### [ Image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "image",
"image": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "audio",
"audio": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 5,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingScope": ["clip", "asset"],
"embeddingOption": ["audio"]
}
}
```
------
#### [ Video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "video",
"video": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 10,
"endSec": 20,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingOption": [
"visual",
"audio"
],
"embeddingScope": [
"clip",
"asset"
]
}
}
```
------
**2. Ejecute la invocación del modelo utilizando la entrada del modelo**
A continuación, añada el fragmento de código que corresponda al método de invocación del modelo que prefiera.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://amzn-s3-demo-bucket"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# Modelos Writer AI Palmyra
En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos de Writer AI. Utilice esta información para realizar llamadas de inferencia a los modelos de Writer AI con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos de Writer AI. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para comprobar si la API Converse es compatible con un modelo de Writer AI específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md).
Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos de Writer AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos de Writer AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos de Writer AI, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
Cuando realiza llamadas de inferencia con modelos de Writer AI, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). Para obtener información específica sobre las peticiones a Writer AI, consulte la [guía de ingeniería de peticiones de Writer AI]().
**Writer Palmyra X4**
Writer Palmyra X4, el mejor valorado en Stanford HELM, logra un rendimiento superior en tareas complejas y flujos de trabajo de agentes. Combina una ventana de contexto de 128 000 tokens con un conjunto de capacidades listas para la empresa, que incluyen razonamiento avanzado, llamada a herramientas, delegación de LLM, RAG integrado, generación de código, salidas estructuradas, varias modalidades y compatibilidad con varios idiomas. Al utilizar herramientas empresariales específicas que amplían la capacidad del modelo de realizar acciones, Palmyra X4 permite a los desarrolladores crear aplicaciones y agentes que actualizan el sistema, realizan transacciones, envían correos electrónicos, activan flujos de trabajo. etc.
**Writer Palmyra X5**
Con una ventana de contexto de un millón de tokens, Writer Palmyra X5 marca el fin de las restricciones contextuales para el desarrollo de aplicaciones y agentes. El modelo más reciente de Writer ofrece un rendimiento superior en inferencia con contextos largos gracias a una memoria ampliada y mayor capacidad de procesamiento, lo que permite a los desarrolladores crear flujos de trabajo agenciales más complejos y de varios pasos con mayor rapidez. Al igual que Palmyra X4, Palmyra X5 incluye un conjunto de capacidades listas para la empresa, que incluyen razonamiento avanzado, llamada a herramientas, delegación de LLM, RAG integrado, generación de código, salidas estructuradas, varias modalidades y compatibilidad con varios idiomas.
**Topics**
+ [Writer Palmyra X4](model-parameters-palmyra-x4.md)
+ [Writer Palmyra X5](model-parameters-palmyra-x5.md)
# Writer Palmyra X4
Writer Palmyra X4 es un modelo con una ventana de contexto de hasta 128 000 tokens. Este modelo destaca en el procesamiento y la comprensión de tareas complejas, lo que lo hace ideal para la automatización de flujos de trabajo, las tareas de programación y el análisis de datos.
+ Proveedor: Writer
+ Categorías: generación de texto, generación de código, formato de texto enriquecido
+ Última versión: v1
+ Fecha de lanzamiento: 28 de abril de 2025
+ ID del modelo: — `writer.palmyra-x4-v1:0`
+ Modalidad: texto
+ Número máximo de tokens: 122 880 tokens de entrada, 8192 tokens de salida
+ Idioma: inglés, español, francés, alemán, chino y otros idiomas
+ Tipo de implementación: sin servidor
## Campo del cuerpo de la solicitud de invocación de Palmyra X4
Cuando realice una llamada a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) con un modelo Writer, rellene el campo `body` con un objeto JSON que se ajuste al siguiente. Introduce la petición en el campo `text` del objeto `text_prompts`.
```
{
"modelId": "writer.palmyra-x4-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
La siguiente tabla muestra los valores mínimo, máximo y predeterminado de los parámetros numéricos.
****
| Parámetro | Tipo | Predeterminado/a | Alcance/Validación | Descripción |
| --- | --- | --- | --- | --- |
| Mensajes | matriz | Obligatorio | 1-∞ elementos | Mensajes del historial de chat |
| temperature | float | 1.0 | 0,0 ≤ x ≤ 2,0 | Temperatura de muestreo |
| top\$1p | float | 1.0 | 0,0 < valor ≤ 1,0 | Umbral de muestreo del núcleo |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8192 | Número máximo de tokens que se pueden generar |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Número mínimo de tokens antes de detenerse |
| parar | matriz | [] | ≤4 entradas | Secuencias de parada |
| valor de inicialización | int | nulo | Cualquier entero | Random seed (Origen aleatorio) |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Penalización por presencia de nuevos tokens |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Penalización por frecuencia de tokens |
## Campo del cuerpo de la respuesta de invocación de Palmyra X4
El JSON de respuesta de Writer Palmyra X4 usa el siguiente formato:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x4-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```
## Writer Palmyra X4Código de ejemplo del
Ejemplos de código de Writer Palmyra X4:
```
import boto3
import json
from botocore.exceptions import ClientError
client = boto3.client("bedrock-runtime", region_name="us-west-2")
model_id = "writer.palmyra-x4-v1:0"
# Format the request payload using the model's native structure.
native_request = {
"temperature": 1,
"messages": [
{
"role": "user",
"content": "Explain quantum computing in simple terms.",
}
],
}
# 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["content"][0]["text"]
print(response_text)
```
# Writer Palmyra X5
Writer Palmyra X5 incluye un conjunto de capacidades listas para la empresa, que incluyen razonamiento avanzado, llamada a herramientas, delegación de LLM, RAG integrado, generación de código, salidas estructuradas, varias modalidades y compatibilidad con varios idiomas.
El modelo Writer Palmyra X5 tiene los controles siguientes:
+ Proveedor: Writer
+ Categorías: generación de texto, generación de código, formato de texto enriquecido
+ Última versión: v1
+ Fecha de lanzamiento: 28 de abril de 2025
+ ID del modelo: — `writer.palmyra-x5-v1:0`
+ Modalidad: texto
+ Número máximo de tokens: 1 040 000 tokens de entrada, 8192 tokens de salida
+ Idioma: inglés, español, francés, alemán, chino y otros idiomas
+ Tipo de implementación: sin servidor
## Campo del cuerpo de la solicitud de invocación de Palmyra X5
Cuando realice una llamada a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) con un modelo Writer, rellene el campo `body` con un objeto JSON que se ajuste al siguiente. Introduce la petición en el campo `text` del objeto `text_prompts`.
```
{
"modelId": "writer.palmyra-x5-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
La siguiente tabla muestra los valores mínimo, máximo y predeterminado de los parámetros numéricos.
****
| Parámetro | Tipo | Predeterminado/a | Alcance/Validación | Descripción |
| --- | --- | --- | --- | --- |
| Mensajes | matriz | Obligatorio | 1-∞ elementos | Mensajes del historial de chat |
| temperature | float | 1.0 | 0,0 ≤ x ≤ 2,0 | Temperatura de muestreo |
| top\$1p | float | 1.0 | 0,0 ≤ x ≤ 1,0 | Umbral de muestreo del núcleo |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8192 | Número máximo de tokens que se pueden generar |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Número mínimo de tokens antes de detenerse |
| parar | matriz | [] | ≤4 entradas | Secuencias de parada |
| valor de inicialización | int | nulo | Cualquier entero | Random seed (Origen aleatorio) |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Penalización por presencia de nuevos tokens |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Penalización por frecuencia de tokens |
## Campo del cuerpo de la respuesta de invocación de Palmyra X5
El JSON de respuesta de Writer Palmyra X5 usa el siguiente formato:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x5-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```