Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# 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