\n\nAssistant:",
"temperature": float,
"top_p": float,
"top_k": int,
"max_tokens_to_sample": int,
"stop_sequences": [string]
}
```
Veja a seguir os parâmetros necessários.
+ **prompt**: (obrigatório) o prompt que você deseja que o Claude conclua. Para gerar uma resposta adequada, formate o prompt usando a alternância de turnos de conversas `\n\nHuman:` e `\n\nAssistant:`. Por exemplo:
```
"\n\nHuman: {userQuestion}\n\nAssistant:"
```
Para obter mais informações, consulte [Prompt validation](https://docs.anthropic.com/claude/reference/prompt-validation) na documentação do Claude da Anthropic.
+ **max\$1tokens\$1to\$1sample**: (obrigatório) o número máximo de tokens a serem gerados antes de parar. É recomendável um limite de 4 mil tokens para uma performance ideal.
Observe que os modelos Claude da Anthropic podem parar de gerar tokens antes de atingir o valor de `max_tokens_to_sample`. Modelos diferentes do Claude da Anthropic têm valores máximos diferentes para esse parâmetro. Para obter mais informações, consulte [Model comparison](https://docs.anthropic.com/claude/docs/models-overview#model-comparison) fornecido na documentação do Claude da Anthropic.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
Veja a seguir os parâmetros opcionais.
+ **stop\$1sequences**: (opcional) sequências que farão com que o modelo pare de gerar.
Os modelos Claude da Anthropic param em `"\n\nHuman:"` e podem incluir sequências de parada integradas adicionais no futuro. Use o parâmetro de inferência `stop_sequences` para incluir strings adicionais que sinalizarão ao modelo para parar de gerar texto.
+ **temperature**: (opcional) a aleatoriedade injetada na resposta. Use um valor mais próximo de 0 para a opção de análise/múltipla escolha e um valor mais próximo de 1 para tarefas criativas e generativas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1p**: (opcional) use amostragem de núcleo.
Na amostragem de núcleo, o Claude da Anthropic calcula a distribuição cumulativa de todas as opções de cada token subsequente em ordem de probabilidade decrescente e a interrompe quando atinge uma determinada probabilidade especificada por `top_p`. Você deve alterar `temperature` ou `top_p`, mas não ambos.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1k**: (opcional) somente um exemplo das opções K principais para cada token subsequente.
Use `top_k` para remover respostas de baixa probabilidade de cauda longa.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
------
#### [ Response ]
O modelo Claude da Anthropic retorna os campos a seguir para chamadas de inferência de Text Completion.
```
{
"completion": string,
"stop_reason": string,
"stop": string
}
```
+ **completion**: o preenchimento resultante até as sequências de parada, mas excluindo-as.
+ **stop\$1reason**: o motivo pelo qual o modelo parou de gerar a resposta.
+ **“stop\$1sequence”**: o modelo atingiu uma sequência de parada: fornecida com o parâmetro de inferência `stop_sequences` ou com uma sequência de parada incorporada ao modelo.
+ **“max\$1tokens”**: o modelo excedeu `max_tokens_to_sample` ou o número máximo de tokens do modelo.
+ **stop**: se você especificar o parâmetro de inferência `stop_sequences`, `stop` conterá a sequência de parada que sinalizou ao modelo para parar de gerar texto. Por exemplo, `holes` na resposta a seguir.
```
{
"completion": " Here is a simple explanation of black ",
"stop_reason": "stop_sequence",
"stop": "holes"
}
```
Se você não especificar `stop_sequences`, o valor `stop` estará vazio.
------
## Exemplo de código
Esses exemplos mostram como chamar o modelo *Claude V2 da Anthropic* com throughput sob demanda. Para usar o Claude versão 2.1 da Anthropic, altere o valor de `modelId` para `anthropic.claude-v2:1`.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "\n\nHuman: explain black holes to 8th graders\n\nAssistant:",
"max_tokens_to_sample": 300,
"temperature": 0.1,
"top_p": 0.9,
})
modelId = 'anthropic.claude-v2'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completion'))
```
O seguinte exemplo mostra como gerar texto de streaming com o Python usando o prompt *escreva uma dissertação sobre viver em Marte usando mil palavras* e o modelo Claude V2 da Anthropic:
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```
# API Messages do Claude da Anthropic
Esta seção fornece os parâmetros de inferência e exemplos de código para uso da API Messages do Claude da Anthropic.
**Topics**
+ [Visão geral da API Messages do Claude da Anthropic](#model-parameters-anthropic-claude-messages-overview)
+ [Uso de ferramentas](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Raciocínio estendido](claude-messages-extended-thinking.md)
+ [Pensamento adaptativo](claude-messages-adaptive-thinking.md)
+ [Criptografia de raciocínio](claude-messages-thinking-encryption.md)
+ [Diferenças de raciocínio entre as versões de modelo](claude-messages-thinking-differences.md)
+ [Compactação](claude-messages-compaction.md)
+ [Obtenha resultados JSON validados de modelos](claude-messages-structured-outputs.md)
+ [Solicitação e reposta](model-parameters-anthropic-claude-messages-request-response.md)
+ [Exemplos de código](api-inference-examples-claude-messages-code-examples.md)
+ [Modelos compatíveis](claude-messages-supported-models.md)
## Visão geral da API Messages do Claude da Anthropic
Você pode usar a API Messages para criar chatbots ou aplicações de assistente virtual. A API gerencia as trocas de conversas entre um usuário e um modelo do Claude da Anthropic (assistente).
**nota**
Este tópico mostra como usar a API de Anthropic Claude mensagens com as operações básicas de inferência ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). No entanto, é recomendável usar a API Converse para implementar mensagens em sua aplicação. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Realizar uma conversa com as operações de API Converse](conversation-inference.md).
As restrições se aplicam às seguintes operações: `InvokeModel` `InvokeModelWithResponseStream``Converse`,, `ConverseStream` e. Consulte as [restrições da API](inference-api-restrictions.md) para obter detalhes.
A Anthropic treina modelos Claude para operar em turnos alternados de conversação do usuário e do assistente. Ao criar uma mensagem, você especifica os turnos de conversação anteriores com o parâmetro messages. O modelo acaba gerando a próxima mensagem na conversa.
Cada mensagem de entrada deve ser um objeto com uma função e um conteúdo. Você pode especificar uma única mensagem de função do usuário ou pode incluir várias mensagens de usuário e assistente.
Se você estiver usando a técnica de pré-preencher a resposta do Claude (preenchendo o início da resposta do Claude usando uma mensagem da função de assistente final), o Claude responderá retomando de onde você parou. Com essa técnica, o Claude ainda retornará uma resposta com a função de assistente.
Se a mensagem final usar a função de assistente, o conteúdo da resposta continuará imediatamente a partir do conteúdo dessa mensagem. Você pode usar isso para restringir parte da resposta do modelo.
Exemplo com uma única mensagem do usuário:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Exemplo com vários turnos de conversação:
```
[
{"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?"},
]
```
Exemplo com uma resposta parcialmente preenchida pelo Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
O conteúdo de cada mensagem de entrada pode ser uma string única ou uma matriz dos blocos de conteúdo, em que cada bloco tem um tipo específico. O uso de uma string é um atalho para uma matriz de um bloco de conteúdo do tipo “texto”. As seguintes mensagens de entrada são equivalentes:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Para obter informações sobre como criar prompts para modelos Claude da Anthropic, consulte, [Intro to prompting](https://docs.anthropic.com/claude/docs/intro-to-prompting) na documentação do Claude da Anthropic. Se você tiver prompts de [preenchimento de texto](model-parameters-anthropic-claude-text-completion.md) existentes que deseja migrar para a API de mensagens, consulte [Migrating from Text Completions](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Importante**
O período limite para chamadas de inferência aos modelos Claude 3.7 Sonnet e Claude 4 da Anthropic é 60 minutos. Por padrão, os clientes AWS SDK atingem o tempo limite após 1 minuto. Recomendamos que você aumente o período de tempo limite de leitura do seu cliente AWS SDK para pelo menos 60 minutos. Por exemplo, no botocore do AWS SDK para Python, altere o valor do campo `read_timeout` em [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) para pelo menos 3.600.
### Prompts do sistema
Você também pode incluir um prompt do sistema na solicitação. Um prompt do sistema permite a você contextualizar e dar instruções para o Claude da Anthropic, como especificar uma meta ou função específica. Especifique um prompt do sistema no campo `system`, conforme exibido no exemplo a seguir.
```
"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 obter mais informações, consulte [System prompts](https://docs.anthropic.com/en/docs/system-prompts) na documentação da Anthropic.
### Prompts multimodais
Um prompt multimodal combina várias modalidades (imagens e textos) em um único prompt. Você especifica as modalidades no campo de entrada `content`. O exemplo a seguir mostra como você pode pedir para o Claude da Anthropic descrever o conteúdo de uma imagem fornecida. Para obter um código de exemplo, consulte [Exemplos 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 imagem incluída por você em uma solicitação conta para o uso do token. Para obter mais informações, consulte [Image costs](https://docs.anthropic.com/claude/docs/vision#image-costs) na documentação da Anthropic.
# Uso de ferramentas
**Atenção**
Várias funções abaixo são oferecidas na versão beta, conforme indicado. Esses recursos são disponibilizados para você como um “Serviço Beta”, conforme definido nos Termos do AWS Serviço. Está sujeito ao seu Contrato AWS e aos Termos AWS de Serviço e ao modelo de EULA aplicável.
Com os modelos Claude da Anthropic, você pode especificar uma ferramenta que o modelo pode usar para responder a uma mensagem. Por exemplo, você pode especificar uma ferramenta que obtenha a música mais tocada em uma estação de rádio. Se o usuário transmitir a mensagem *Qual é a música mais tocada na WZPZ?*, o modelo determinará que a ferramenta especificada pode ajudar a responder à pergunta. Na resposta, o modelo solicita a você executar a ferramenta em seu nome. Em seguida, você executa a ferramenta e passa o resultado da ferramenta para o modelo, que gera uma resposta para a mensagem original. Para obter mais informações, consulte [Tool use (function calling)](https://docs.anthropic.com/en/docs/tool-use) na documentação do Claude da Anthropic.
**dica**
É recomendável usar a API Converse para integrar o uso de ferramentas à aplicação. Para obter mais informações, consulte [Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock](tool-use.md).
**Importante**
O Claude Sonnet 4.5 agora preserva a formatação intencional nos parâmetros da string de chamada da ferramenta. Antes, as novas linhas finais nos parâmetros de string às vezes eram incorretamente removidas. Essa correção garante que as ferramentas que exigem formatação precisa (como editores de texto) recebam os parâmetros exatamente como pretendido. Essa é uma behind-the-scenes melhoria sem a necessidade de alterações na API. No entanto, as ferramentas com parâmetros de string agora podem receber valores com novas linhas à direita que foram removidas anteriormente.
**nota**
O Claude Sonnet 4.5 inclui otimizações automáticas para melhorar o desempenho do modelo. Essas otimizações podem adicionar pequenas quantidades de tokens às solicitações, mas você não recebe cobranças por esses tokens adicionados pelo sistema.
Você especifica as ferramentas que deseja disponibilizar para um modelo no campo `tools`. O exemplo a seguir é de uma ferramenta que obtém as músicas mais tocadas em uma estação de rádio.
```
[
{
"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"
]
}
}
]
```
Quando precisa de uma ferramenta para gerar uma resposta a uma mensagem, o modelo retorna informações sobre a ferramenta solicitada, e a entrada para a ferramenta no campo `content` da mensagem. Ele também define o motivo da interrupção da resposta para `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"
}
```
No código, você chama a ferramenta em nome das ferramentas. Em seguida, você passa o resultado da ferramenta (`tool_result`) em uma mensagem do usuário para o modelo.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
Na resposta, o modelo usa o resultado da ferramenta a fim de gerar uma resposta para a mensagem 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"
}
```
## Streaming refinado de ferramentas
O streaming refinado de ferramentas é um recurso do modelo Claude da Anthropic disponível no Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 e Claude Opus 4. Com o streaming refinado de ferramentas, os desenvolvedores do Claude podem transmitir parâmetros de uso de ferramentas sem os armazenar em buffer ou sem validação JSON, reduzindo a latência para começar a receber parâmetros grandes.
**nota**
Ao usar o streaming refinado de ferramentas, é possível que você receba entradas JSON inválidas ou parciais. Considere esses casos extremos em seu código.
Para usar esse recurso, basta adicionar o cabeçalho `fine-grained-tool-streaming-2025-05-14` a uma solicitação de uso de ferramentas.
Veja aqui um exemplo de como especificar o cabeçalho de streaming refinado de ferramentas:
```
{
"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"
]
}
}
]
}
```
Neste exemplo, o streaming refinado de ferramentas permite que o Claude transmita as estrofes de um longo poema à chamada de ferramenta `make_file` sem os armazenar em buffer para validar se o parâmetro `lines_of_text` é um JSON válido. Isso significa que você pode ver o fluxo de parâmetros à medida que ele chega, sem precisar esperar que todo o parâmetro seja armazenado em buffer e validado.
Com o streaming refinado de ferramentas, os fragmentos de uso de ferramentas começam a ser transmitidos mais depressa e geralmente são mais longos e contêm menos quebras de palavra. Isso se deve a diferenças no comportamento de fragmentação.
Por exemplo, sem streaming refinado (atraso de 15 s):
```
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'
...
```
Com streaming refinado (atraso de 3 s):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**nota**
Como o streaming refinado envia parâmetros sem os armazenar em buffer ou sem validação JSON, não há garantia de que o fluxo resultante será concluído em uma string JSON válida. Mais especificamente, se o motivo de interrupção `max_tokens` for atingido, o fluxo poderá terminar no meio de um parâmetro e ficar incompleto. Geralmente, é necessário escrever um suporte específico para lidar com situações em que `max_tokens` é atingido.
## Computer Use (Beta)
Computer Use é um recurso do modelo Claude da Anthropic (em beta) disponível no Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 e Claude Opus 4. Com o Computer Use, o Claude pode ajudar a automatizar tarefas por meio de ações básicas da GUI.
**Atenção**
O recurso de uso do computador é disponibilizado para você como um “Serviço Beta”, conforme definido nos Termos do AWS Serviço. Está sujeito ao seu Contrato AWS e aos Termos AWS de Serviço e ao modelo de EULA aplicável. Esteja ciente de que a API Computer Use apresenta riscos exclusivos que são distintos dos recursos padrão de API ou das interfaces de chat. Esses riscos aumentam ao usar a API Computer Use para interagir com a internet. Para minimizar os riscos, considere tomar precauções, como:
Operar a funcionalidade Computer Use em uma máquina virtual ou contêiner dedicado com privilégios mínimos para evitar acidentes ou ataques diretos ao sistema.
Para impedir o roubo de informações, evite fornecer à API Computer Use acesso a contas ou dados sensíveis.
Limitar o acesso APIs à Internet pelo computador aos domínios necessários para reduzir a exposição a conteúdo malicioso.
Para garantir a supervisão adequada, mantenha uma pessoa informada sobre tarefas confidenciais (como tomar decisões que possam ter consequências significativas no mundo real) e sobre qualquer coisa que exija consentimento afirmativo (como aceitar cookies, executar transações financeiras ou concordar com os termos de serviço).
Qualquer conteúdo que você permita que o Claude veja ou acesse pode potencialmente substituir as instruções ou provocar erros no Claude ou executar ações indesejadas. Tomar as devidas precauções, como isolar o Claude de superfícies confidenciais, é essencial, inclusive para evitar riscos relacionados à injeção de prompt. Antes de habilitar ou solicitar as permissões necessárias para habilitar os recursos do Computer Use em seus próprios produtos, informe os usuários finais sobre quaisquer riscos relevantes e obtenha o consentimento deles conforme apropriado.
A API Computer Use oferece várias ferramentas Computer User predefinidas para você usar. É possível criar um prompt com sua solicitação, como “enviar um e-mail para Ben com as anotações da minha última reunião” e uma captura de tela (quando necessário). A resposta contém uma lista de ações de `tool_use` no formato JSON (por exemplo, scroll\$1down, left\$1button\$1press, screenshot). Seu código executa as ações do computador e fornece ao Claude uma captura de tela mostrando as saídas (quando solicitado).
Desde o lançamento do Claude 3.5 v2, o parâmetro tools foi atualizado para aceitar tipos de ferramentas polimórficas; a propriedade `tool.type` foi adicionada para diferenciá-las. `type` é opcional; se omitida, a ferramenta será considerada uma ferramenta personalizada (anteriormente o único tipo de ferramenta compatível). Para acessar a Computer Use, você deve usar o parâmetro `anthropic_beta`, com uma enumeração correspondente, cujo valor depende da versão do modelo em uso. Consulte a tabela a seguir para obter mais informações.
Somente solicitações feitas com esse parâmetro e enum podem usar as ferramentas Computer Use. Ele pode ser especificado da seguinte forma: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modelo | Cabeçalho 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 obter mais informações, consulte [Computer Use (beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) na documentação da Anthropic.
Esta é uma resposta de exemplo que pressupõe que a solicitação continha uma captura de tela da área de trabalho com um ícone do 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
}
}
```
## Ferramentas definidas do Anthropic
A Anthropic oferece um conjunto de ferramentas para permitir que determinados modelos Claude usem computadores de forma eficaz. Ao especificar uma ferramenta definida da Anthropic, os campos `description` e `tool_schema` não são necessários nem permitidos. As ferramentas definidas da Anthropic são definidas pela Anthropic, mas você deve avaliar explicitamente os resultados da ferramenta e retornar os `tool_results` para o Claude. Tal como ocorre com qualquer ferramenta, o modelo não executa automaticamente a ferramenta. Cada ferramenta definida da Anthropic tem versões otimizadas para modelos Claude 3.5 Sonnet (novos) e Claude 3.7 Sonnet específicos:
| Modelo | Ferramenta | Observações |
| --- | --- | --- |
| 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"
} | Atualização para a ferramenta `str_replace_editor` existente |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Inclui novas ações para um controle mais preciso |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Mesmos recursos da versão 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Mesmos recursos da versão 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"
} |
O campo `type` identifica a ferramenta e os respectivos parâmetros para fins de validação, enquanto o campo `name` é o nome da ferramenta exposto ao modelo.
Se você quiser solicitar que o modelo use uma dessas ferramentas, poderá indicar explicitamente a ferramenta por meio do campo `name`. O campo `name` deve ser exclusivo na lista de ferramentas. Não é possível definir uma ferramenta com o mesmo `name` de uma ferramenta definida da Anthropic na mesma chamada de API.
## Limpeza automática de chamadas de ferramenta (beta)
**Atenção**
A ferramenta automática de compensação de chamadas é disponibilizada como um “Serviço Beta”, conforme definido nos Termos AWS de Serviço.
**nota**
Atualmente, esse recurso é suportado no Claude Sonnet 4/4.5, no Claude Haiku 4.5 e no Claude Opus 4/4.1/4.5.
A compensação automática de chamadas de ferramentas é um recurso do modelo Anthropic Claude (em versão beta). Com esse recurso, Claude pode apagar automaticamente os resultados de uso de ferramentas antigas à medida que você se aproxima dos limites dos tokens, permitindo um gerenciamento de contexto mais eficiente em cenários de uso de ferramentas de vários turnos. Para usar a limpeza de uso de ferramentas, você precisa adicionar `context-management-2025-06-27` à lista de cabeçalhos beta no parâmetro de solicitação anthropic\$1beta. Você também precisará especificar o uso `clear_tool_uses_20250919` e escolher entre as seguintes opções de configuração.
Esses são os controles disponíveis para a estratégia de gerenciamento de contexto `clear_tool_uses_20250919`. Todos são opcionais ou têm padrões:
| **Opção de configuração** | **Descrição** |
| --- | --- |
| `trigger` padrão: 100.000 tokens de entrada | Define quando a estratégia de edição de contexto é ativada. Quando o prompt ultrapassar esse limite, a limpeza começará. É possível especificar esse valor em input\$1tokens ou tool\$1uses. |
| `keep` padrão: 3 usos de ferramentas | Define quantos use/result pares de ferramentas recentes devem ser mantidos após a limpeza. A API remove primeiro as interações mais antigas da ferramenta, preservando as mais recentes. Útil quando o modelo precisa acessar interações recentes da ferramenta para continuar a conversa de forma eficaz. |
| `clear_at_least` (opcional) | Garante que um número mínimo de tokens seja liberado cada vez que a estratégia é ativada. Se a API não conseguir liberar pelo menos o valor especificado, a estratégia não será aplicada. Isso é útil para determinar se vale a pena invalidar o armazenamento em cache de prompts para limpar o contexto. |
| `exclude_tools` (opcional) | Lista de nomes cujos usos e resultados da ferramenta nunca devem ser apagados. Útil para preservar um contexto importante. |
| `clear_tool_inputs`: (opcional; padrão: false) | Controla se os parâmetros de chamada da ferramenta são apagados com os resultados da ferramenta. Por padrão, somente os resultados da ferramenta são apagados, mantendo as chamadas de ferramenta originais do Claude visíveis para que o Claude veja quais operações foram realizadas mesmo após a remoção dos resultados. |
**nota**
A limpeza de ferramenta invalidará o cache se os prefixos contiverem suas ferramentas.
------
#### [ 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**
Atualmente, o Bedrock não oferece suporte ao gerenciamento de `clear_tool_uses_20250919` contexto na CountTokens API.
## Ferramenta de memória (beta)
**Atenção**
O Memory Tool é disponibilizado como um “Serviço Beta”, conforme definido nos Termos do AWS Serviço.
O Claude Sonnet 4.5 inclui uma nova ferramenta de memória que oferece aos clientes uma maneira de gerenciar a memória em todas as conversas. Com esse recurso, os clientes podem permitir que o Claude recupere informações fora da janela de contexto fornecendo acesso a um diretório local. Isso estará disponível como um recurso beta. Para usar esse recurso, você deve usar o cabeçalho beta `context-management-2025-06-27`.
Definição da ferramenta:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Exemplo de solicitação:
```
{
"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?"}]
}
]
}
```
Exemplo de resposta:
```
{
"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": []
}
}
```
## Considerações sobre custo para uso de ferramentas
O preço das solicitações de uso de ferramentas é baseado nos seguintes fatores:
1. O número total de tokens de entrada enviados ao modelo (inclusive no parâmetro tools).
1. Número de tokens de saída gerados.
As ferramentas têm o mesmo preço de todas as outras solicitações de API do Claude, mas incluem tokens adicionais por solicitação. Os tokens adicionais de uso de ferramentas provêm do seguinte:
+ Inclua o parâmetro `tools` nas solicitações de API. Por exemplo, nomes, descrições e esquemas de ferramenta.
+ Qualquer bloco de conteúdo de `tool_use` em solicitações e respostas de API.
+ Qualquer bloco de conteúdo de `tool_result` em solicitações de API.
Quando você usa ferramentas, os modelos da Anthropic incluem automaticamente um prompt especial do sistema que permite usar a ferramenta. O número de tokens de uso de ferramentas necessários para cada modelo está listado na tabela a seguir. Essa tabela exclui os tokens adicionais descritos anteriormente. Observe que essa tabela pressupõe que pelo menos uma ferramenta seja fornecida. Se nenhuma ferramenta for fornecida e se for escolhido nenhuma para a opção de ferramenta, não será usado nenhum token de prompt adicional do sistema.
| Modelo | Escolha da ferramenta | Contagem de tokens de prompt do sistema de uso de ferramentas |
| --- | --- | --- |
| 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 ou 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 ou tool | 313 |
| Claude 3.5 Sonnet | auto ou none | 294 |
| Claude 3.5 Sonnet | any ou tool | 261 |
| Claude 3 Opus | auto ou none | 530 |
| Claude 3 Opus | any ou tool | 281 |
| Claude 3 Sonnet | auto ou none | 159 |
| Claude 3 Sonnet | any ou tool | 235 |
| Claude 3 Haiku | auto ou none | 264 |
| Claude 3 Haiku | any ou tool | 340 |
## Ferramenta de pesquisa de ferramentas (beta)
A ferramenta de pesquisa de ferramentas Claude permite trabalhar com centenas ou até milhares de ferramentas sem carregar todas as suas definições na janela de contexto antecipadamente. Em vez de declarar todas as ferramentas imediatamente, você pode marcá-las com`defer_loading: true`, Claude localizar e carregar somente as ferramentas necessárias por meio do mecanismo de busca de ferramentas.
Para acessar esse recurso, você deve usar o cabeçalho beta`tool-search-tool-2025-10-19`. Observe que atualmente esse recurso está disponível apenas por meio do [InvokeModel[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) APIse.
Definição da ferramenta:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Exemplo de solicitação:
```
{
"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?"
}]
}
```
Exemplo de resposta
```
{
"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"
}
```
Exemplo 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
}
```
**Ferramentas de pesquisa de ferramentas personalizadas**
Você pode implementar ferramentas personalizadas de pesquisa de ferramentas (por exemplo, usando incorporações) definindo uma ferramenta que retorna `tool_reference` blocos. A ferramenta personalizada deve ter, `defer_loading: false` enquanto outras ferramentas deveriam ter`defer_loading: true`. Quando você define sua própria ferramenta de pesquisa de ferramentas, ela deve retornar um resultado da ferramenta contendo blocos de `tool_reference` conteúdo que apontam para as ferramentas que você Claude deseja usar.
O formato esperado de resposta dos resultados da Ferramenta de Pesquisa de Ferramentas definido pelo cliente:
```
{
"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`Deve corresponder a uma ferramenta definida na solicitação com`defer_loading: true`. Claude então terá acesso aos esquemas completos dessas ferramentas.
**Ferramentas de pesquisa personalizadas - Exemplo detalhado**
Você pode implementar ferramentas personalizadas de pesquisa de ferramentas (por exemplo, usando incorporações ou pesquisa semântica) definindo uma ferramenta que retorna `tool_reference` blocos. Isso permite mecanismos sofisticados de descoberta de ferramentas além da correspondência de regex.
Exemplo de solicitação com 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?"
}]
}
```
Claudeda resposta (chamando o 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 da ferramenta fornecida pelo cliente**
Depois de realizar uma pesquisa semântica na biblioteca de ferramentas, o cliente retorna as referências de ferramentas correspondentes:
```
{
"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"
}]
}
}]
}
```
Claudeacompanhamento (usando a ferramenta descoberta)
```
{
"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"
}
```
**Tratamento de erros**
+ A configuração `defer_loading: true` de todas as ferramentas (incluindo a Ferramenta de Pesquisa de Ferramentas) gerará um erro 400.
+ Passar um `tool_reference` sem uma definição de ferramenta correspondente gerará um erro 400
## Exemplos de uso de ferramentas (beta)
Claude Opus4.5 oferece suporte a exemplos fornecidos pelo usuário em definições de ferramentas para aumentar o desempenho Claude do uso da ferramenta. Você pode fornecer exemplos como chamadas de função completas, formatadas exatamente como seriam as saídas reais do LLM, sem precisar de tradução para outro formato. Para usar esse recurso, você deve passar o cabeçalho beta`tool-examples-2025-10-29`.
Exemplo de definição de ferramenta:
```
{
"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"
}
]
}
```
**Regras de validação**
+ Conformidade do esquema: cada exemplo em `input_examples` deve ser válido de acordo com a ferramenta. `input_schema`
+ Os campos obrigatórios devem estar presentes em pelo menos um exemplo.
+ Os tipos de campo devem corresponder ao esquema.
+ Os valores de enumeração devem ser do conjunto permitido.
+ Se a validação falhar, retorne um erro 400 com detalhes sobre qual exemplo falhou na validação.
+ Requisitos de matriz: `input_examples` deve ser uma matriz (pode estar vazia).
+ `[]`A matriz vazia é válida e equivale a omitir o campo.
+ Um único exemplo ainda deve ser agrupado em uma matriz: `[{...}]`
+ Limite de comprimento: comece com um limite de 20 exemplos por definição de ferramenta.
Exemplos de erros:
```
// 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"
}
```
# Raciocínio estendido
O pensamento estendido fornece recursos Claude aprimorados de raciocínio para tarefas complexas, ao mesmo tempo em que fornece níveis variados de transparência em seu processo de step-by-step pensamento antes de fornecer sua resposta final. Sempre que você habilitar o modo de raciocínio do Claude, precisará definir um orçamento para o número máximo de tokens que o Claude pode usar no processo de raciocínio interno.
Os modelos compatíveis são os seguintes:
| Modelo | ID do 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**
O comportamento da API difere entre os modelos Claude 3.7 e Claude 4. Para obter mais informações, consulte [Diferenças de raciocínio entre as versões de modelo](claude-messages-thinking-differences.md).
**Topics**
+ [Práticas recomendadas e considerações para raciocínio estendido](#claude-messages-extended-thinking-bps)
+ [Como funciona o raciocínio estendido](#claude-messages-how-extended-thinking-works)
+ [Como usar o raciocínio estendido](#claude-messages-use-extended-thinking)
+ [Raciocínio estendido com o uso de ferramentas](#claude-messages-extended-thinking-tool-use)
+ [Limpeza de blocos de pensamento (beta)](#claude-messages-thinking-block-clearing)
+ [Raciocínio estendido com o armazenamento em cache de prompts](#claude-messages-extended-thinking-prompt-caching)
+ [Noções básicas sobre o comportamento do armazenamento em cache de blocos de raciocínio](#claude-messages-extended-thinking-caching-behavior)
+ [Máximo de tokens e tamanho da janela de contexto com raciocínio estendido](#claude-messages-extended-thinking-max-tokens)
+ [Considerações sobre o custo de tokens de raciocínio estendido](#claude-messages-extended-thinking-cost)
## Práticas recomendadas e considerações para raciocínio estendido
Diretrizes de uso
+ **Seleção de tarefas**: use o pensamento estendido para tarefas particularmente complexas que se beneficiam do step-by-step raciocínio, como matemática, codificação e análise.
+ **Tratamento do contexto**: você não precisa remover os blocos de raciocínio anteriores. A API da Anthropic ignora automaticamente os blocos de raciocínio de turnos anteriores e eles não são incluídos no cálculo de uso do contexto.
+ **Engenharia de prompts**: analise as [dicas de raciocínio estendido da Anthropic](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) se quiser maximizar a capacidade de raciocínio do Claude.
Considerações sobre a performance
+ **Tempos de resposta**: prepare-se para tempos de resposta possivelmente mais longos devido ao processamento adicional necessário ao processo de raciocínio. Considere que a geração de blocos de raciocínio pode aumentar o tempo geral de resposta.
+ **Requisitos de streaming**: o streaming é necessário quando `max_tokens` for maior que 21.333. Ao fazer streaming, prepare-se para com os blocos de conteúdo `thinking` e `text` à medida que eles chegarem.
Compatibilidade de recursos
+ Não é possível usar o recurso de raciocínio com as modificações `temperature`, `top_p` ou `top_k` ou o [uso de ferramenta forçado](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Você não pode preencher previamente as respostas quando o raciocínio está habilitado.
+ Alterações no orçamento de raciocínio invalidam prefixos de prompt armazenados em cache que incluem mensagens. No entanto, os prompts do sistema armazenados em cache e as definições de ferramentas continuarão a funcionar quando os parâmetros de raciocínio mudarem.
Como trabalhar com orçamentos de raciocínio
+ **Otimizações de orçamento**: o orçamento mínimo é de 1.024 tokens. A Anthropic sugere começar pelo mínimo e aumentar gradualmente o orçamento de raciocínio para encontrar a faixa ideal para seu caso de uso. Contagens maiores de tokens podem permitir um raciocínio mais abrangente e diferenciado, mas também pode haver retornos decrescentes dependendo da tarefa. O orçamento previsto é uma meta e não um limite estrito: o uso real do token pode variar de acordo com a tarefa.
+ **Configurações mínimas e ideais**: o orçamento mínimo é de 1.024 tokens. Sugerimos começar pelo mínimo e aumentar gradualmente o orçamento de raciocínio para encontrar a faixa ideal para o Claude ter um bom desempenho para seu caso de uso. Um número maior de tokens pode permitir que você obtenha um raciocínio mais abrangente e diferenciado, mas também pode haver retornos decrescentes dependendo da tarefa. O orçamento previsto é uma meta e não um limite estrito: o uso real do token pode variar de acordo com a tarefa.
+ **Experimentação**: o modelo pode ter um desempenho diferente em diferentes configurações de orçamento máximo de raciocínio. Aumentar o orçamento máximo de raciocínio pode fazer com que o modelo pense melhor ou mais refletidamente, com a desvantagem de aumentar a latência. Para tarefas essenciais, considere testar diferentes configurações de orçamento para encontrar o equilíbrio ideal entre qualidade e desempenho.
+ **Grandes orçamentos**: para pensar em orçamentos acima de 32 mil, recomendamos usar o processamento em lote para evitar problemas de rede. Solicitações que forçam o modelo a pensar acima de 32 mil tokens causam solicitações de longa duração que podem resultar em tempos limite do sistema e limites de conexão abertos. Observe que os limites de `max_tokens` variam entre os modelos Claude. Para obter mais informações, consulte [Máximo de tokens e tamanho da janela de contexto com raciocínio estendido](#claude-messages-extended-thinking-max-tokens).
+ **Rastreamento do uso de tokens**: monitore o uso de tokens de raciocínio para otimizar os custos e o desempenho.
## Como funciona o raciocínio estendido
Quando o raciocínio estendido é ativado, o Claude cria blocos de conteúdo `thinking` nos quais ele produz seu raciocínio interno. O Claude incorpora insights desse raciocínio antes de elaborar uma resposta final. A resposta da API incluirá blocos de conteúdo `thinking`, seguidos de blocos de conteúdo `text`.
Veja um exemplo do formato de resposta padrão:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Para ter mais informações sobre o formato de resposta do raciocínio estendido, consulte a API Messages da Anthropic em [Solicitação e reposta](model-parameters-anthropic-claude-messages-request-response.md).
## Como usar o raciocínio estendido
Para ativar o raciocínio estendido, adicione um objeto `thinking`, com o parâmetro `thinking` definido como habilitado e `budget_tokens` definido como um orçamento simbólico especificado para o raciocínio estendido.
O parâmetro `budget_tokens` determina o número máximo de tokens do Claude que podem ser usados no processo interno de raciocínio. No modelos Claude 4, esse limite se aplica aos tokens de raciocínio completo, e não à saída resumida. Orçamentos maiores podem melhorar a qualidade da resposta, permitindo uma análise mais completa de problemas complexos, embora exista a possibilidade de o Claude não usar todo o orçamento alocado, especialmente em limites acima de 32 mil.
O valor de `budget_tokens` deve ser definido como um valor menor que `max_tokens`. No entanto, ao usar o [Raciocínio intercalado (beta)](#claude-messages-extended-thinking-tool-use-interleaved) com ferramentas, você pode exceder esse limite porque o limite de tokens se torna a janela de contexto completa (200 mil tokens).
### Raciocínio resumido
Com o raciocínio estendido habilitado, a API Messages para os modelos Claude 4 exibe um resumo do processo de raciocínio completo do Claude. O raciocínio resumido oferece todos os benefícios de inteligência do raciocínio estendido, ao mesmo tempo que evita o uso indevido.
Estas são algumas considerações importantes sobre o raciocínio resumido:
+ Você recebe cobrança pelos tokens de raciocínio completos gerados pela solicitação original, não pelos tokens resumidos.
+ A contagem de tokens de saída cobrados não corresponderá à contagem de tokens visíveis na resposta.
+ O prompt fornecido ao modelo de resumo está sujeito a alterações.
+ As primeiras linhas de raciocínio são mais detalhadas, fornecendo um raciocínio detalhado que é particularmente útil para fins de engenharia de prompts.
**nota**
O Claude 3.7 Sonnet ainda exibe a saída completa de raciocínio.
Para acessar a saída completa de raciocínio dos modelos Claude 4, entre em contato com sua equipe de contas.
### Streaming de raciocínio
É possível transmitir respostas de raciocínio estendido usando eventos enviados pelo servidor (SSE). Quando o streaming está habilitado para o raciocínio estendido, você recebe conteúdo de raciocínio por meio de eventos `thinking_delta`. Não é garantido que os eventos transmitidos sejam exibidos a uma taxa constante. Pode haver atrasos entre os eventos de streaming. Para ver outra documentação sobre streaming por meio da API Messages, consulte [Streaming messages](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
Veja como lidar com o streaming pensando usando **InvokeModelWithResponseStream**:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Resposta:
```
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"}
```
**Sobre o comportamento de streaming com raciocínio**
Ao usar o streaming com o raciocínio ativado, você pode notar que o texto às vezes chega em partes maiores, alternando com uma entrega menor. token-by-token Esse é o comportamento esperado, especialmente para o conteúdo de raciocínio. O sistema de streaming precisa processar o conteúdo em lote para obter um desempenho ideal, o que pode resultar nesse padrão de entrega.
## Raciocínio estendido com o uso de ferramentas
O raciocínio estendido pode ser usado com [Uso de ferramentas](model-parameters-anthropic-claude-messages-tool-use.md), permitindo que o Claude raciocine por meio da seleção de ferramentas e do processamento de resultados. Ao usar o raciocínio estendido com o uso de ferramentas, esteja ciente das seguintes limitações:
+ **Limitação da escolha de ferramentas**: o uso de ferramenta com raciocínio permite apenas `tool_choice: any`. Não é possível oferecer uma ferramenta específica, `auto`, ou quaisquer outros valores.
+ **Preservação de blocos de raciocínio**: durante o uso da ferramenta, você deve transmitir os blocos de raciocínio de volta à API para receber a última mensagem do assistente. Inclua o bloco completo não modificado na API para manter a continuidade do raciocínio.
Veja como o gerenciamento de janelas de contexto funciona com ferramentas:
```
{
"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?"
}
]
}
```
A primeira resposta é a seguinte:
```
{
"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"
}
}
]
}
```
Se a conversa for continuada com o uso de ferramentas, será gerada outra resposta. Observe que `thinking_block` é transmitido, assim como `tool_use_block`. Se isso não for transmitido, ocorrerá um erro.
```
{
"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"
}
]
}
]
}
```
Agora a resposta da API incluirá apenas texto.
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Preservar blocos de raciocínio
Durante o uso da ferramenta, você deve transmitir os blocos de raciocínio de volta à API e incluir novamente o bloco completo não modificado na API. Isso é fundamental para manter o fluxo de raciocínio e a integridade da conversa do modelo.
**dica**
Embora você possa omitir os blocos `thinking` antes de turnos da função `assistant`, sugerimos sempre transmitir todos os blocos de raciocínio de volta à API para qualquer conversa de vários turnos. A API fará o seguinte:
Filtrará automaticamente os blocos de raciocínio fornecidos.
Usará os blocos de raciocínio relevantes necessários para preservar o raciocínio do modelo.
Cobrará apenas pelos tokens de entrada dos blocos mostrados para o Claude.
Quando o Claude invoca ferramentas, ele pausa a criação de uma resposta para aguardar informações externas. Quando os resultados da ferramenta são exibidos, o Claude continua criando a resposta existente. Isso exige a preservação dos blocos de raciocínio durante o uso da ferramenta, pelos seguintes motivos:
+ **Continuidade do raciocínio**: os blocos de pensamento capturam Claude o step-by-step raciocínio que levou às solicitações de ferramentas. Quando você publica os resultados da ferramenta, a inclusão do blocos de raciocínio original garante que o Claude continue seu raciocínio de onde ele parou.
+ **Preservação do contexto**: embora os resultados da ferramenta apareçam como mensagens do usuário na estrutura da API, eles fazem parte de um fluxo contínuo de raciocínio. A preservação dos blocos de raciocínio mantém esse fluxo conceitual em várias chamadas de API.
**Importante**
Ao fornecer blocos de raciocínio, toda a sequência de blocos de raciocínio consecutivos deve corresponder às saídas geradas pelo modelo durante a solicitação original. A sequência desses blocos não pode ser reorganizada nem modificada.
### Raciocínio intercalado (beta)
**Atenção**
O pensamento intercalado é disponibilizado para você como um “Serviço Beta”, conforme definido nos Termos do Serviço. AWS Está sujeito ao seu Contrato AWS e aos Termos AWS de Serviço e ao modelo de EULA aplicável.
Os modelos Claude 4 oferecem raciocínio intercalado, um recurso que permite que o Claude reflita entre as chamadas de ferramenta e raciocine de uma maneira mais elaborada depois de receber os resultados da ferramenta. Isso permite interações agênticas mais complexas nas quais o Claude pode fazer o seguinte:
+ Pensar nos resultados de uma chamada de ferramenta antes de decidir o que fazer em seguida.
+ Encadear várias chamadas de ferramenta com etapas intermediárias de raciocínio.
+ Tomar decisões mais sutis com base em resultados intermediários.
Para permitir o raciocínio intercalado, adicione o cabeçalho beta `interleaved-thinking-2025-05-14` à solicitação de API.
**nota**
Com o raciocínio intercalado, `budget_tokens` pode exceder o parâmetro `max_tokens` porque representa o orçamento total em todos os blocos de raciocínio em um turno de assistente.
## Limpeza de blocos de pensamento (beta)
**Atenção**
A compensação do Thinking block é disponibilizada como um “Serviço Beta”, conforme definido nos Termos AWS de Serviço.
**nota**
Atualmente, esse recurso é compatível com Claude Sonnet 4/4.5, Claude Haiku 4.5 e Claude Opus 4/4.1/4.5.
A eliminação de blocos de pensamento é uma capacidade do modelo Anthropic Claude (em versão beta). Com esse recurso, Claude pode eliminar automaticamente os bloqueios de pensamento mais antigos dos turnos anteriores. Para usar a limpeza de blocos do Thinking, você precisa adicionar `context-management-2025-06-27` à lista de cabeçalhos beta no parâmetro de solicitação anthropic\$1beta. Você também precisará especificar o uso `clear_thinking_20251015` e escolher entre as seguintes opções de configuração.
Esses são os controles disponíveis para a estratégia de gerenciamento de contexto `clear_thinking_20251015`. Todos são opcionais ou têm padrões:
| **Opção de configuração** | **Descrição** |
| --- | --- |
| `keep` padrão: 1 volta de pensamento | Define quantos assistentes recentes usam blocos de pensamento para preservar. Use `{"type": "thinking_turns", "value": N}` onde N deve ser > 0 para manter os últimos N turnos ou `{"type": "all"}` para manter todos os blocos de pensamento. |
------
#### [ 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": [...]
}
}
```
------
## Raciocínio estendido com o armazenamento em cache de prompts
Há várias considerações importantes sobre o [armazenamento em cache de prompts](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) com raciocínio:
**Remoção do contexto do bloco de raciocínio**
+ Os blocos de raciocínio dos turnos anteriores são removidos do contexto, o que pode afetar os pontos de interrupção do cache.
+ Ao continuar as conversas com o uso de ferramentas, os blocos de raciocínio são armazenados em cache e contabilizados como tokens de entrada quando lidos do cache. Isso cria uma desvantagem, pois, embora os blocos de raciocínio não consumam visualmente o espaço da janela de contexto, eles serão contabilizados para o uso do token de entrada quando armazenados em cache.
+ Se o raciocínio for desabilitado, as solicitações falharão se você passar o conteúdo do raciocínio no turno atual de uso de ferramenta. Em outros contextos, o conteúdo do raciocínio transmitido à API é simplesmente ignorado.
**Padrões de invalidação de cache**
+ Alterações nos parâmetros de raciocínio (como habilitar, desabilitar ou alterar a alocação do orçamento) invalidam os pontos de interrupção do cache de mensagens.
+ O [Raciocínio intercalado (beta)](#claude-messages-extended-thinking-tool-use-interleaved) amplifica a invalidação do cache, pois podem ocorrer blocos de raciocínio entre várias chamadas de ferramenta.
+ Os prompts e ferramentas do sistema permanecem armazenados em cache, apesar das alterações no parâmetro de raciocínio ou da remoção de blocos.
**nota**
Embora os blocos de raciocínio sejam removidos para cálculos de armazenamento em cache e contexto, eles devem ser preservados ao continuar conversas com o uso de ferramentas, especialmente com raciocínio intercalado.
## Noções básicas sobre o comportamento do armazenamento em cache de blocos de raciocínio
Ao usar o raciocínio estendido com o uso de ferramentas, os blocos de raciocínio exibem um comportamento específico de armazenamento em cache que afeta a contagem de tokens. A sequência a seguir demonstra como isso funciona.
1. O armazenamento em cache ocorre somente quando você faz uma solicitação subsequente que inclui os resultados da ferramenta.
1. Quando a solicitação subsequente é feita, o histórico da conversa anterior (inclusive os blocos de raciocínio) pode ser armazenado em cache.
1. Esses blocos de raciocínio armazenados em cache são contabilizados como tokens de entrada em suas métricas de uso quando são lidos do cache.
1. Quando um bloco de non-tool-result usuário é incluído, todos os blocos de pensamento anteriores são ignorados e retirados do contexto.
Veja aqui um exemplo detalhado de fluxo:
Solicitação 1:
```
User: "What's the weather in Paris?"
```
Resposta 1:
```
[thinking_block 1] + [tool_use block 1]
```
Solicitação 2:
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Resposta 2:
```
[thinking_block 2] + [text block 2]
```
A solicitação 2 grava o conteúdo da solicitação em cache (não da resposta). O cache inclui a mensagem original do usuário, o primeiro bloco de raciocínio, o bloco de uso da ferramenta e o resultado da ferramenta.
Solicitação 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 um bloco de non-tool-result usuário foi incluído, todos os blocos de pensamento anteriores são ignorados. Essa solicitação será processada da mesma forma que a seguinte solicitação:
Alternativa à solicitação 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]
```
Esse comportamento é consistente, seja usando o raciocínio regular ou o raciocínio intercalado.
## Máximo de tokens e tamanho da janela de contexto com raciocínio estendido
Nos modelos Claude mais antigos (anteriores ao Claude 3.7 Sonnet), se a soma de tokens de prompt e max\$1tokens excedesse a janela de contexto do modelo, o sistema ajustava automaticamente max\$1tokens de acordo com o limite de contexto. Isso significava que, embora você pudesse definir um grande valor para max\$1tokens, o sistema o reduziria silenciosamente conforme a necessidade. Com os modelos Claude 3.7 e 4, `max_tokens` (que inclui seu orçamento de raciocínio quando o raciocínio está habilitado), é imposto como um limite estrito. O sistema agora exibirá um erro de validação se tokens de prompts \$1 max\$1tokens exceder o tamanho da janela de contexto.
### A janela de contexto com raciocínio estendido
Ao calcular o uso da janela de contexto com o raciocínio habilitado, é necessário considerar o seguinte:
+ Os blocos de raciocínio dos turnos anteriores são removidos e não são contabilizados na sua janela de contexto.
+ O raciocínio do turno atual é contabilizado para o limite `max_tokens` desse turno.
A janela de contexto efetiva é calculada como: janela de contexto = (tokens de entrada atuais - tokens de raciocínio anteriores) \$1 (tokens de raciocínio \$1 tokens de raciocínio criptografados \$1 tokens de saída de texto).
### Gerenciar tokens com raciocínio estendido e uso de ferramentas
Ao usar o raciocínio estendido com o uso de ferramentas, os blocos de raciocínio devem ser explicitamente preservados e exibidos com os resultados da ferramenta. O cálculo efetivo da janela de contexto para o raciocínio estendido com uso de ferramentas torna-se o seguinte:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Gerenciar tokens com raciocínio estendido
Considerando a janela de contexto e o comportamento de `max_tokens` dos modelos de raciocínio estendido Claude 3.7 e 4, talvez seja necessário realizar uma das seguintes ações:
+ Monitorar e gerenciar mais ativamente o uso de tokens.
+ Ajustar os valores de `max_tokens` à medida que o tamanho do prompt muda.
+ Estar ciente de que os blocos de raciocínio anteriores não se acumulam na sua janela de contexto. Essa alteração foi feita para oferecer um comportamento mais previsível e transparente, especialmente porque os limites máximos de tokens aumentaram significativamente.
## Considerações sobre o custo de tokens de raciocínio estendido
O processo de raciocínio incorre em cobranças para o seguinte:
+ tokens usados durante o raciocínio (tokens de saída);
+ blocos de raciocínio do último turno do assistente incluídos nas solicitações subsequentes (tokens de entrada);
+ tokens de saída de texto padrão.
**dica**
Quando o raciocínio estendido está habilitado, um prompt especializado do sistema de 28 ou 29 tokens é incluído automaticamente para atender a esse recurso.
O parâmetro `budget_tokens` determina o número máximo de tokens do Claude que podem ser usados no processo interno de raciocínio. Orçamentos maiores podem melhorar a qualidade da resposta, permitindo uma análise mais completa de problemas complexos, embora o Claude possa não usar todo o orçamento alocado, especialmente em limites acima de 32 mil.
Com o raciocínio intercalado, `budget_tokens` pode exceder o parâmetro `max_tokens`, pois representa o orçamento total em todos os blocos de raciocínio em um turno do assistente.
Ao usar o raciocínio resumido, lembre-se das seguintes informações:
+ **Tokens de entrada**: tokens em sua solicitação original.
+ **Tokens de saída (faturados)**: os tokens do raciocínio original que o Claude gerou internamente.
+ **Tokens de saída (visíveis)**: os tokens do raciocínio resumido que você vê na resposta.
+ **Sem cobrança**: os tokens usados para gerar o resumo.
+ O campo `summary_status` pode indicar se os limites de token afetaram o resumo.
+ A contagem de tokens de saída cobrados não corresponderá à contagem de tokens visíveis na resposta. Você recebe cobranças por todo o processo de raciocínio, não pelo resumo que você vê.
# Pensamento adaptativo
O pensamento adaptativo é a forma recomendada de usar [Raciocínio estendido](claude-messages-extended-thinking.md) com o Claude Opus 4.6. Em vez de definir manualmente um orçamento simbólico, o pensamento adaptativo permite decidir Claude dinamicamente quando e quanto pensar com base na complexidade de cada solicitação. O pensamento adaptativo gera um desempenho melhor de forma confiável do que o pensamento estendido com um pensamento fixo`budget_tokens`, e recomendamos mudar para o pensamento adaptativo para obter as respostas mais inteligentes do 4.6. Claude Opus Nenhum cabeçalho beta é necessário.
Os modelos compatíveis são os seguintes:
| Modelo | ID do modelo |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
**nota**
`thinking.type: "enabled"`e `budget_tokens` estão obsoletos na versão Claude Opus 4.6 e serão removidos em uma versão futura do modelo. Em vez disso, use `thinking.type: "adaptive"` com o parâmetro de esforço.
Modelos mais antigos (Claude Sonnet 4.5, Claude Opus 4.5, etc.) não suportam o pensamento adaptativo e exigem`thinking.type: "enabled"`. `budget_tokens`
## Como funciona o pensamento adaptativo
No modo adaptativo, Claude avalia a complexidade de cada solicitação e decide se e em quanto pensar. No nível de esforço padrão (`high`), quase sempre Claude pensará. Em níveis mais baixos de esforço, Claude pode deixar de pensar em problemas mais simples.
O pensamento adaptativo também é ativado automaticamente. [Raciocínio intercalado (beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved) Isso significa que Claude pode pensar entre chamadas de ferramentas, tornando-a especialmente eficaz para fluxos de trabalho agentes.
`thinking.type`Defina como `"adaptive"` na sua solicitação 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);
```
------
## Pensamento adaptativo com o parâmetro de esforço
Você pode combinar o pensamento adaptativo com o parâmetro de esforço para orientar o quanto Claude o pensamento faz. O nível de esforço atua como uma orientação suave para a alocação Claude do pensamento:
| Nível de esforço | Comportamento de pensamento |
| --- | --- |
| max | Claudesempre pensa sem restrições na profundidade do pensamento. Claude OpusSomente 4.6 — solicitações usadas max em outros modelos retornarão um erro. |
| high (padrão) | Claudesempre pensa. Fornece um raciocínio profundo sobre tarefas complexas. |
| medium | Claudeusa pensamento moderado. Pode deixar de pensar em perguntas muito simples. |
| low | Claudeminimiza o pensamento. Pare de pensar em tarefas simples, nas quais a velocidade é mais importante. |
## Armazenamento em cache de prompts
Solicitações consecutivas usando o `adaptive` thinking preservam pontos de interrupção imediatos do cache. No entanto, alternar entre `adaptive` os modos `enabled` `disabled` e/thinking interrompe os pontos de interrupção do cache das mensagens. Os prompts do sistema e as definições de ferramentas permanecem em cache, independentemente das alterações de modo.
## Ajustando o comportamento de pensamento
Se Claude estiver pensando com mais ou menos frequência do que gostaria, você pode adicionar orientações ao prompt do 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.
```
**Atenção**
ClaudePassar a pensar com menos frequência pode reduzir a qualidade das tarefas que se beneficiam do raciocínio. Meça o impacto em suas cargas de trabalho específicas antes de implantar o ajuste baseado em solicitações na produção. Considere testar primeiro com níveis de esforço mais baixos.
# Criptografia de raciocínio
O conteúdo de raciocínio completo é criptografado e exibido no campo de assinatura. Esse campo é usado para verificar se os blocos de raciocínio foram gerados pelo Claude quando transmitidos de volta à API. Ao transmitir respostas, a assinatura é adicionada por meio de `content_block_delta` dentro de um evento `signature_delta` um pouco antes do evento `content_block_stop`.
**nota**
É estritamente necessário devolver blocos de raciocínio ao usar ferramentas com raciocínio estendido. Caso contrário, você pode omitir os blocos de raciocínio dos turnos anteriores ou deixar que a API os remova para você se você os devolver.
Ao devolver blocos de raciocínio, recomendamos devolver tudo conforme você os recebeu, para fins de consistência e para evitar possíveis problemas.
## Edição de raciocínio no Claude 3.7 Sonnet
**nota**
As informações a seguir se aplicam especificamente aos modelos Claude 3.7 Sonnet e Claude 4 que lidam com o raciocínio de forma diferente e não produzem blocos de raciocínio editados.
No Claude 3.7 Sonnet, o seguinte se aplica:
+ Ocasionalmente, o raciocínio interno do Claude será sinalizado por nossos sistemas de segurança. Quando isso ocorre, criptografamos parte ou todo o bloco de raciocínio e o devolvemos a você como um bloco redacted\$1thinking. Os blocos redacted\$1thinking são descriptografados quando devolvidos à API, permitindo que o Claude dê continuidade à resposta sem perder o contexto.
+ Os blocos `thinking` e `redacted_thinking` são exibidos antes dos blocos de texto na resposta.
Ao criar aplicações voltadas para o cliente que usam o raciocínio estendido com o Claude 3.7 Sonnet, você deve:
+ Lembrar-se de que os blocos de raciocínio editados contêm conteúdo criptografado que não é legível por humanos.
+ Considerar a possibilidade de fornecer uma explicação simples, como: “Alguns raciocínios internos do Claude foram criptografados automaticamente por motivos de segurança. Isso não afeta a qualidade das respostas”.
+ Filtrar os blocos editados e, ao mesmo tempo, preservar os blocos de raciocínio normais, se você exibir blocos de raciocínio para os usuários.
+ Ser transparente, pois, ao usar recursos de raciocínio estendido, ocasionalmente algum raciocínio pode acabar sendo criptografado.
+ Implementar o tratamento adequado de erros para gerenciar com tranquilidade o raciocínio editado sem provocar falhas em sua interface de usuário.
Veja abaixo um exemplo que mostra blocos de raciocínio normais e editados:
```
{
"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..."
}
]
}
```
**dica**
Ver blocos de raciocínio editados em sua saída é um comportamento esperado. O modelo ainda assim pode usar esse raciocínio editado para respaldar as respectivas respostas, mantendo as barreiras de proteção de segurança.
Se precisar testar o tratamento do raciocínio editado em sua aplicação, é possível usar esta string de teste especial como prompt: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`.
Ao transmitir os blocos `thinking` e `redacted_thinking` de volta à API em uma conversa de vários turnos, é necessário incluir o bloco completo não modificado de volta na API para o último turno do assistente. Isso é fundamental para manter o fluxo de raciocínio. Sugerimos sempre devolver todos os blocos de raciocínio à API. Para obter mais detalhes, consulte [Raciocínio estendido com o uso de ferramentasPreservar blocos de raciocínio](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
O exemplo a seguir usa a **InvokeModelWithResponseStream**API para demonstrar a estrutura de solicitação e resposta ao usar tokens de pensamento com redações.
Quando o streaming estiver habilitado, você receberá conteúdo inteligente dos eventos thinking\$1delta. Veja como lidar com o streaming com raciocínio:
**Solicitação**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Resposta**
```
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"}
```
# Diferenças de raciocínio entre as versões de modelo
A API Messages lida com o raciocínio de forma diferente nos modelos Claude 3.7 Sonnet e Claude 4, principalmente com relação ao comportamento de edição e resumo. A tabela a seguir resume essas diferenças.
| Recurso | Claude 3.7 Sonnet | Modelos Claude 4 |
| --- | --- | --- |
| Saída do raciocínio | Exibe a saída completa do raciocínio. | Exibe o raciocínio resumido. |
| Tratamento de edição | Usa blocos de `redacted_thinking`. | Edita e criptografa o raciocínio completo, exibido em um campo `signature`. |
| Pensamento intercalado | Não compatível | Compatível se for usado um cabeçalho beta. |
# Compactação
**dica**
A compactação do lado do servidor é recomendada para gerenciar o contexto em conversas de longa duração e fluxos de trabalho agentes, pois lida com o gerenciamento de contexto automaticamente com o mínimo de trabalho de integração.
**nota**
A compactação está atualmente na versão beta. Inclua o cabeçalho beta `compact-2026-01-12` em suas solicitações de API para usar esse recurso. Atualmente, a compactação não é suportada pela Converse API, mas é compatível com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
A compactação amplia a duração efetiva do contexto para conversas e tarefas de longa duração ao resumir automaticamente o contexto antigo ao se aproximar do limite da janela de contexto. Isso é ideal para:
+ Conversas de vários turnos baseadas em bate-papo, nas quais você deseja que os usuários usem um bate-papo por um longo período de tempo
+ Solicitações orientadas a tarefas que exigem muito trabalho de acompanhamento (geralmente uso de ferramentas) que podem exceder a janela de contexto de 200K
A compactação é suportada nos seguintes modelos:
| Modelo | ID do modelo |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**nota**
O nível superior `input_tokens` e `output_tokens` o de `usage` campo não incluem o uso da iteração de compactação e refletem a soma de todas as iterações sem compactação. Para calcular o total de tokens consumidos e cobrados por uma solicitação, some todas as entradas na `usage.iterations` matriz.
Se você já confiou no `usage.input_tokens` controle `usage.output_tokens` de custos ou na auditoria, precisará atualizar sua lógica de rastreamento para agregar `usage.iterations` quando a compactação estiver ativada. A `iterations` matriz só está presente quando uma nova compactação é acionada durante a solicitação. A reaplicação de um `compaction` bloco anterior não acarreta nenhum custo adicional de compactação, e os campos de uso de nível superior permanecem precisos nesse caso.
## Como funciona a compactação
Quando a compactação está ativada, resume Claude automaticamente sua conversa quando ela se aproxima do limite de token configurado. A API:
1. Detecta quando os tokens de entrada excedem o limite de gatilho especificado.
1. Gera um resumo da conversa atual.
1. Cria um `compaction` bloco contendo o resumo.
1. Continua a resposta com o contexto compactado.
Nas solicitações subsequentes, anexe a resposta às suas mensagens. A API descarta automaticamente todos os blocos de mensagens antes do `compaction` bloqueio, continuando a conversa a partir do resumo.
## Uso básico
Ative a compactação adicionando a `compact_20260112` estratégia à sua solicitação `context_management.edits` da API de mensagens.
------
#### [ 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);
```
------
## Parâmetros
| Parâmetro | Tipo | Padrão | Description |
| --- | --- | --- | --- |
| type | string | Obrigatório | Deve ser "compact\$120260112" |
| trigger | objeto | 150.000 tokens | Quando acionar a compactação. Deve ter pelo menos 50.000 tokens. |
| pause\$1after\$1compaction | booleano | false | Se deve pausar após gerar o resumo da compactação |
| instructions | string | null | Solicitação de resumo personalizada. Substitui completamente o prompt padrão quando fornecido. |
## Configurações do gatilho
Configure quando a compactação é acionada usando o parâmetro: `trigger`
```
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"])
```
## Instruções de resumo personalizadas
Por padrão, a compactação usa o seguinte prompt de resumo:
```
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.
```
Você pode fornecer instruções personalizadas por meio do `instructions` parâmetro para substituir totalmente esse prompt. As instruções personalizadas não complementam o padrão; elas o substituem completamente:
```
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 após a compactação
Use `pause_after_compaction` para pausar a API depois de gerar o resumo da compactação. Isso permite que você adicione blocos de conteúdo adicionais (como preservar mensagens recentes ou mensagens específicas orientadas a instruções) antes que a API continue com a resposta.
Quando ativada, a API retorna uma mensagem com o motivo da `compaction` parada após gerar o bloco de compactação:
```
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"])
```
## Trabalhando com blocos de compactação
Quando a compactação é acionada, a API retorna um `compaction` bloco no início da resposta do assistente.
Uma conversa de longa duração pode resultar em várias compactações. O último bloco de compactação reflete o estado final do prompt, substituindo o conteúdo anterior pelo resumo gerado.
```
{
"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..."
}
]
}
```
## Streaming
Ao transmitir respostas com a compactação ativada, você receberá um `content_block_start` evento quando a compactação começar. O bloco de compactação é transmitido de forma diferente dos blocos de texto. Você receberá um `content_block_start` evento, seguido por um single `content_block_delta` com o conteúdo resumido completo (sem streaming intermediário) e, em seguida, um `content_block_stop` evento.
## Armazenamento em cache de prompts
Você pode adicionar um `cache_control` ponto de interrupção nos blocos de compactação, que armazena em cache o prompt completo do sistema junto com o conteúdo resumido. O conteúdo original compactado é ignorado. Observe que, quando a compactação é acionada, isso pode resultar em uma perda de cache na solicitação subsequente.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Entendendo o uso
A compactação requer uma etapa adicional de amostragem, que contribui para os limites de taxa e o faturamento. A API retorna informações detalhadas de uso na resposta:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
A `iterations` matriz mostra o uso de cada iteração de amostragem. Quando a compactação ocorrer, você verá uma `compaction` iteração seguida pela iteração principal`message`. As contagens de tokens da iteração final refletem o tamanho efetivo do contexto após a compactação.
# Obtenha resultados JSON validados de modelos
Você pode usar saídas estruturadas com Claude Sonnet 4.5Claude Haiku 4.5,Claude Opus 4.5, e. Claude Opus 4.6 Para saber mais, consulte [Obtenha resultados JSON validados de modelos](structured-output.md).
# Solicitação e reposta
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**nota**
As restrições se aplicam às seguintes operações: `InvokeModel` `InvokeModelWithResponseStream``Converse`,, `ConverseStream` e. Consulte as [restrições da API](inference-api-restrictions.md) para obter detalhes.
**Atenção**
Claude Sonnet 4.5e Claude Haiku 4.5 suporte para especificar o `top_p` parâmetro `temperature` ou, mas não ambos. Isso não se aplica aos modelos mais antigos.
------
#### [ Request ]
O Claude da Anthropic tem os parâmetros de inferência a seguir para uma chamada de inferência de mensagens.
```
{
"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]
}
```
Veja a seguir os parâmetros necessários.
+ **anthropic\$1version**: (obrigatório) a versão da Anthropic. O valor deve ser `bedrock-2023-05-31`.
+ **max\$1tokens**: (obrigatório) o número máximo de tokens a serem gerados antes de parar.
Observe que os modelos Claude da Anthropic podem parar de gerar tokens antes de atingir o valor de `max_tokens`. Modelos diferentes do Claude da Anthropic têm valores máximos diferentes para esse parâmetro. Para obter mais informações, consulte [Model comparison](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages**: (obrigatório) as mensagens de entrada.
+ **role**: o perfil do turno da conversa. Os valores válidos são `user` e `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content**: (obrigatório) o conteúdo do turno da conversa, como uma matriz de objetos. Cada objeto contém um campo de **tipo**, no qual você pode especificar um dos seguintes valores:
+ `text`: se você especificar esse tipo, deverá incluir um campo de **texto** e especificar o prompt de texto como o respectivo valor. Se outro objeto na matriz for uma imagem, esse prompt de texto se aplicará às imagens.
+ `image`: se você especificar esse tipo, deverá incluir um campo de **origem** associado a um objeto com os seguintes campos:
+ **type**: (obrigatório) o tipo de codificação da imagem. Você pode especificar `base64`.
+ **media\$1type**: (obrigatório) o tipo da imagem. Você pode especificar os seguintes formatos de imagem:
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data**: (obrigatório) os bytes de imagem codificados em base64 para a imagem. O tamanho máximo da imagem é 3,75 MB. O valor da altura e da largura máximas de uma imagem é 8.000 pixels.
Veja a seguir os parâmetros opcionais.
+ **system**: (opcional) o prompt do sistema para a solicitação.
Um prompt do sistema é uma maneira de contextualizar e dar instruções para o Claude da Anthropic, como especificar uma meta ou função específica. Para obter mais informações, consulte [System prompts](https://docs.anthropic.com/en/docs/system-prompts) na documentação da Anthropic.
**nota**
Você pode usar os prompts do sistema com o Claude versão 2.1 ou posterior da Anthropic.
+ **anthropic\$1beta**: (opcional) o parâmetro anthropic\$1beta é uma lista de strings de cabeçalhos beta usados para indicar a aceitação de um conjunto específico de recursos beta.
**nota**
A variante de tamanho de contexto de 1 milhão de tokens de Claude Sonnet 4 está disponível para você em AWS regiões selecionadas como um “Serviço Beta”, conforme definido nos Termos AWS de Serviço. Está sujeito ao seu Contrato AWS e aos Termos AWS de Serviço e ao modelo de EULA aplicável. Consulte a página [Preços do Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/) para ter mais informações sobre os preços para solicitações de contexto mais longas. Aplicam-se cotas de serviço separadas (para obter mais informações, consulte Cotas **de serviço** no Console de gerenciamento da AWS).
Os cabeçalhos beta disponíveis incluem os seguintes:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences**: (opcional) sequências de texto personalizadas que fazem com que o modelo deixe de gerar. Os modelos Claude da Anthropic normalmente param quando completam a vez naturalmente; nesse caso, o valor do campo de resposta `stop_reason` é `end_turn`. Se quiser que o modelo deixe de ser gerado ao encontrar strings de texto personalizadas, você poderá usar o parâmetro `stop_sequences`. Se o modelo encontrar uma das strings de texto personalizadas, o valor do campo de resposta `stop_reason` será `stop_sequence` e o valor de `stop_sequence` conterá a sequência de parada correspondente.
O número máximo de entradas é 8.191.
+ **temperature**: (opcional) a randomização injetada na resposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p**: (opcional) use amostragem de núcleo.
Na amostragem de núcleo, o Claude da Anthropic calcula a distribuição cumulativa de todas as opções de cada token subsequente em ordem de probabilidade decrescente e a interrompe quando atinge uma determinada probabilidade especificada por `top_p`. Ao ajustar os parâmetros de amostragem, modifique `temperature` ou `top_p`. Não modifique ambos ao mesmo tempo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k**: (opcional) somente um exemplo das opções K principais para cada token subsequente.
Use `top_k` para remover respostas de baixa probabilidade de cauda longa.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools**: (opcional) definições de ferramentas que o modelo pode usar.
**nota**
Exige um modelo Claude 3 da Anthropic.
Se você incluir `tools` na solicitação, o modelo poderá retornar blocos de conteúdo `tool_use` que representam o uso dessas ferramentas do modelo. É possível executar essas ferramentas usando a entrada de ferramenta gerada pelo modelo e, opcionalmente, retornar os resultados ao modelo usando blocos de conteúdo de `tool_result`.
Você pode passar os seguintes tipos de ferramenta:
**Personalizada**
Definição de uma ferramenta personalizada.
+ (opcional) **type**: o tipo da ferramenta. Se definido, use o valor `custom`.
+ **name**: o nome da ferramenta.
+ **description**: (opcional, mas altamente recomendado) a descrição da ferramenta.
+ **input\$1schema**: o esquema JSON da ferramenta.
**Computação**
Definição da ferramenta de computação usada por você com a API Computer Use.
+ **type**: o valor deve ser `computer_20241022`.
+ **name**: o valor deve ser `computer`.
+ (Obrigatório) **display\$1height\$1px**: a altura da tela que está sendo controlada pelo modelo, em pixels.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Obrigatório) **display\$1width\$1px**: a largura da tela que está sendo controlada pelo modelo, em pixels.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Opcional) **display\$1number**: o número de exibição a ser controlado (só relevante para ambientes X11). Se especificada, a ferramenta receberá um número de exibição na definição da ferramenta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definição da ferramenta de bash usada por você com a API Computer Use.
+ (opcional) **type**: o valor deve ser `bash_20241022`.
+ **name**: o valor deve ser `bash`.
**text editor**
Definição da ferramenta de edição de texto usada por você com a API Computer Use.
+ (opcional) **type**: o valor deve ser `text_editor_20241022`.
+ **name**: o valor deve ser `str_replace_editor`.
+ **tool\$1choice**: (opcional) especifica como o modelo deve usar as ferramentas fornecidas. O modelo pode usar uma ferramenta específica, qualquer ferramenta disponível ou decidir por conta própria.
**nota**
Exige um modelo Claude 3 da Anthropic.
+ **type**: o tipo de opção de ferramenta. Os valores possíveis são `any` (use qualquer ferramenta disponível), `auto` (o modelo decide) e `tool` (use a ferramenta especificada).
+ **name**: (opcional) o nome da ferramenta a ser usada. Obrigatório se você especificar `tool` no campo `type`.
------
#### [ Response ]
O modelo Claude da Anthropic exibe os campos a seguir para uma chamada de inferência de mensagens.
```
{
"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
}
}
```
Exemplos de resposta com novos valores 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**: o identificador exclusivo da resposta. O formato e o tamanho do ID podem mudar com o passar do tempo.
+ **model**: o ID do modelo Claude da Anthropic que fez a solicitação.
+ **stop\$1reason**: o motivo pelo qual o Claude da Anthropic deixou de gerar a resposta.
+ **end\$1turn**: o modelo atingiu um ponto de parada natural
+ **max\$1tokens**: o texto gerado excedeu o valor do campo de entrada `max_tokens` ou eo número máximo de tokens que o modelo permite.
+ **stop\$1sequence**: o modelo gerou uma das sequências de parada especificadas por você no campo de entrada `stop_sequences`.
+ **refusal**: o Claude se recusa a gerar uma resposta devido a questões de segurança.
+ **tool\$1use**: o claude está chamando uma ferramenta e espera que você a execute.
+ **model\$1context\$1window\$1exceeded**: o modelo interrompeu a geração devido ao limite da janela de contexto.
+ Novo no Claude Sonnet 4.5
+ **stop\$1sequence**: a sequência de parada que encerrou a geração.
+ **type**: o tipo de resposta. O valor é sempre `message`.
+ **role**: a função conversacional da mensagem gerada. O valor é sempre `assistant`.
+ **content**: o conteúdo gerado pelo modelo. Retornado como uma matriz. Há três tipos de conteúdo: *text*, *tool\$1use* e *image*.
+ *text*: uma resposta em texto.
+ **type**: o tipo do conteúdo. Este valor é `text`.
+ **text**: se o valor de `type` for text, conterá o texto do conteúdo.
+ *tool\$1use*: uma solicitação do modelo para usar uma ferramenta.
+ **type**: o tipo do conteúdo. Este valor é `tool_use`.
+ **id**: o ID da ferramenta cujo uso o modelo está solicitando.
+ **name**: contém o nome da ferramenta solicitada.
+ **input**: os parâmetros de entrada a serem passados para a ferramenta.
+ *image*: uma solicitação do modelo para usar uma ferramenta.
+ **type**: o tipo do conteúdo. Este valor é `image`.
+ **source**: contém a imagem. Para obter mais informações, consulte [Prompts multimodais](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage**: contêiner para o número de tokens fornecidos por você na solicitação e o número de tokens que o modelo gerou na resposta.
+ **input\$1tokens**: o número de tokens de entrada na solicitação.
+ **output\$1tokens**: o número de tokens gerados pelo modelo na resposta.
+ **stop\$1sequence**: o modelo gerou uma das sequências de parada especificadas por você no campo de entrada `stop_sequences`.
------
## Parâmetro de esforço (beta)
O `effort` parâmetro é uma alternativa para pensar em orçamentos simbólicos para Claude Opus 4,5. Esse parâmetro indica com Claude que liberalidade ele deve gastar tokens para produzir o melhor resultado, ajustando o uso do token ao pensamento, às chamadas de ferramentas e à comunicação com o usuário. Ele pode ser usado com ou sem o modo de pensamento estendido.
O parâmetro de esforço pode ser definido como:
+ `high`(padrão) — Claude gasta quantos tokens forem necessários para obter o melhor resultado
+ `medium`— Uso balanceado de tokens
+ `low`— Uso conservador de tokens
Para usar esse recurso, você deve passar o cabeçalho beta`effort-2025-11-24`.
Exemplo de solicitação:
```
{
"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"
}]
}
```
# Exemplos de código
Os exemplos de código a seguir mostram como usar a API de mensagens.
**Topics**
+ [Exemplo do código de mensagens](#api-inference-examples-claude-messages-code-example)
+ [Exemplos de código multimodal](#api-inference-examples-claude-multimodal-code-example)
## Exemplo do código de mensagens
Este exemplo mostra como enviar uma mensagem de usuário em um único turno e um turno de usuário com uma mensagem de assistente pré-preenchida para um modelo Claude 3 Sonnet da Anthropic.
```
# 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()
```
## Exemplos de código multimodal
Os exemplos a seguir mostram como passar uma imagem e um texto de prompt em uma mensagem multimodal para um modelo Claude 3 Sonnet da Anthropic.
**Topics**
+ [Prompt multimodal com InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Streaming de prompt multimodal com InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Prompt multimodal com InvokeModel
O exemplo a seguir mostra como enviar um prompt multimodal para 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()
```
### Streaming de prompt multimodal com InvokeModelWithResponseStream
O exemplo a seguir mostra como transmitir a resposta de um prompt multimodal enviado para 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 compatíveis
Você pode usar a API Messages com os modelos Claude da Anthropic a seguir.
+ 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
+ Claude 3.5 Sonnet v2 da Anthropic
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Claude 2 v2.1 da Anthropic
+ Claude 2 v2 da Anthropic
+ Claude Instant v1.2 da Anthropic
# Modelos da AI21 Labs
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da AI21 Labs. Use essas informações para fazer chamadas de inferência a modelos da AI21 Labs com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da AI21 Labs. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da AI21 Labs específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da AI21 Labs, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da AI21 Labs, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS esses modelos da AI21 Labs estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da AI21 Labs, inclua um prompt no modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para obter informações de prompts específicos da AI21 Labs, consulte o [AI21 Labs prompt engineering guide](https://docs.ai21.com/docs/prompt-engineering).
**Topics**
+ [Modelos Jurassic-2 da AI21 Labs](model-parameters-jurassic2.md)
+ [Modelos Jamba da AI21 Labs](model-parameters-jamba.md)
# Modelos Jurassic-2 da AI21 Labs
Esta seção fornece os parâmetros de inferência e um exemplo de código para usar os modelos AI21 Labs Jurassic-2 da AI21 Labs.
**Topics**
+ [Parâmetros de inferência](#model-parameters-jurassic2-request-response)
+ [Exemplo de código](#api-inference-examples-a2i-jurassic)
## Parâmetros de inferência
Os modelos Jurassic-2 da AI21 Labs são compatíveis com os parâmetros de inferência a seguir.
**Topics**
+ [Randomização e diversidade](#model-parameters-jurassic2-random)
+ [Tamanho](#model-parameters-jurassic2-length)
+ [Repetições](#model-parameters-jurassic2-reps)
+ [Campo do corpo da solicitação de invocação do modelo](#model-parameters-jurassic2-request-body)
+ [Campo do corpo da resposta de invocação do modelo](#model-parameters-jurassic2-response-body)
### Randomização e diversidade
Os modelos Jurassic-2 da AI21 Labs são compatíveis com os parâmetros a seguir para controlar a randomização e a diversidade na resposta.
+ **Temperature** (`temperature`): use um valor menor para reduzir a randomização na resposta.
+ **Top P** (`topP`): use um valor menor para ignorar opções menos prováveis.
### Tamanho
Os modelos Jurassic-2 da AI21 Labs são compatíveis com os parâmetros a seguir para controlar o tamanho da resposta gerada.
+ **Duração máximo de conclusão** (`maxTokens`): especifique o número máximo de tokens a serem usados na resposta gerada.
+ **Sequências de parada** (`stopSequences`): configure as sequências de parada que o modelo reconhece e após as quais ele para de gerar mais tokens. Pressione a tecla Enter para inserir um caractere de nova linha em uma sequência de parada. Use a tecla Tab para finalizar a inserção de uma sequência de parada.
### Repetições
Os modelos Jurassic-2 da AI21 Labs são compatíveis com os parâmetros a seguir para controlar a repetição na resposta gerada.
+ **Penalidade de presença** (`presencePenalty`): use um valor maior para reduzir a probabilidade de gerar novos tokens que já apareçam pelo menos uma vez no prompt ou na conclusão.
+ **Penalidade de contagem** (`countPenalty`): use um valor maior para diminuir a probabilidade de gerar novos tokens que já aparecem pelo menos uma vez no prompt ou na conclusão. Proporcional ao número de aparições.
+ **Penalidade de frequência** (`frequencyPenalty`): use um valor alto para diminuir a probabilidade de gerar novos tokens que já apareçam pelo menos uma vez no prompt ou na conclusão. O valor é proporcional à frequência das aparições do token (normalizado para o tamanho do texto).
+ **Penalize tokens especiais**: reduza a probabilidade de repetição de caracteres especiais. Os valores padrão são `true`.
+ **Espaços em branco** (`applyToWhitespaces`): um valor `true` aplica a penalidade a espaços em branco e novas linhas.
+ **Pontuações** (`applyToPunctuation`): um valor `true` aplica a penalidade à pontuação.
+ **Números** (`applyToNumbers`): um valor `true` aplica a penalidade aos números.
+ **Palavras de interrupção** (`applyToStopwords`): um valor `true` aplica a penalidade às palavras de interrupção.
+ **Emojis** (`applyToEmojis`): um valor `true` exclui emojis da penalidade.
### Campo do corpo da solicitação de invocação do modelo
Ao fazer uma chamada [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) usando um modelo da AI21 Labs, preencha o campo `body` com um objeto JSON que esteja em conformidade com o modelo a seguir. Insira o prompt no campo `prompt`.
```
{
"prompt": string,
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": [string],
"countPenalty": {
"scale": float
},
"presencePenalty": {
"scale": float
},
"frequencyPenalty": {
"scale": float
}
}
```
Para penalizar tokens especiais, adicione esses campos a qualquer um dos objetos de penalidade. Por exemplo, você pode modificar o campo `countPenalty` da seguinte maneira.
```
"countPenalty": {
"scale": float,
"applyToWhitespaces": boolean,
"applyToPunctuations": boolean,
"applyToNumbers": boolean,
"applyToStopwords": boolean,
"applyToEmojis": boolean
}
```
A tabela a seguir mostra os valores mínimo, máximo e padrão para os parâmetros numéricos.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-jurassic2.html)
### Campo do corpo da resposta de invocação do modelo
Para obter informações sobre o formato do campo `body` na resposta, consulte [https://docs.ai21.com/reference/j2-complete-api-ref](https://docs.ai21.com/reference/j2-complete-api-ref).
**nota**
O Amazon Bedrock retorna o identificador de resposta (`id`) como um valor inteiro.
## Exemplo de código
Este exemplo mostra como chamar o modelo *A2I Jurassic-2 Mid da AI21 Labs*.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "Translate to spanish: 'Amazon Bedrock is the easiest way to build and scale generative AI applications with base models (FMs)'.",
"maxTokens": 200,
"temperature": 0.5,
"topP": 0.5
})
modelId = 'ai21.j2-mid-v1'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(
body=body,
modelId=modelId,
accept=accept,
contentType=contentType
)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completions')[0].get('data').get('text'))
```
# Modelos Jamba da AI21 Labs
Esta seção fornece os parâmetros de inferência e um exemplo de código para usar os modelos Jamba da AI21 Labs.
**Topics**
+ [Campos obrigatórios](#model-parameters-jamba-required-fields)
+ [Parâmetros de inferência](#model-parameters-jamba-request-response)
+ [Campo do corpo da solicitação de invocação do modelo](#model-parameters-jamba-request-body)
+ [Campo do corpo da resposta de invocação do modelo](#model-parameters-jamba-response-body)
+ [Exemplo de código](#api-inference-examples-a2i-jamba)
+ [Exemplo de código do Jamba 1.5 Large](#api-inference-examples-a2i-jamba15-large)
## Campos obrigatórios
Os modelos Jamba da AI21 Labs são compatíveis com os seguintes campos obrigatórios:
+ **Mensagens** (`messages`): as mensagens anteriores neste chat, da mais antiga (índice 0) à mais recente. Deve haver pelo menos uma mensagem de usuário ou de assistente na lista. Inclua as entradas do usuário e as respostas do sistema. O tamanho total máximo da lista é de cerca de 256K tokens. Cada mensagem inclui os seguintes membros:
+ **Perfil** (`role`): o perfil do autor da mensagem. Um dos seguintes valores:
+ **Usuário** (`user`): entrada fornecida pelo usuário. Quaisquer instruções fornecidas aqui que entrem em conflito com as instruções fornecidas no prompt do `system` têm precedência sobre as instruções do prompt do `system`.
+ **Assistente** (`assistant`): resposta gerada pelo modelo.
+ **Sistema** (`system`): instruções iniciais fornecidas ao sistema para oferecer orientação geral sobre o tom e a voz da mensagem gerada. Uma mensagem inicial do sistema é opcional, mas é recomendada para fornecer orientação sobre o tom do chat. Por exemplo, “Você é um chatbot útil com formação em ciências da terra e um charmoso sotaque francês”.
+ **Conteúdo** (`content`): o conteúdo da mensagem.
## Parâmetros de inferência
Os modelos Jamba da AI21 Labs são compatíveis com os parâmetros de inferência a seguir.
**Topics**
+ [Aleatoriedade e diversidade](#model-parameters-jamba-random)
+ [Tamanho](#model-parameters-jamba-length)
+ [Repetições](#model-parameters-jamba-reps)
### Aleatoriedade e diversidade
Os modelos Jamba da AI21 Labs são compatíveis com os parâmetros a seguir para controlar a aleatoriedade e a diversidade na resposta.
+ **Temperatura** (`temperature`): quanto de variação deve ser fornecido em cada resposta. A definição desse valor como 0 garante sempre a mesma resposta à mesma pergunta. A definição de um valor mais alto incentiva mais variações. Modifica a distribuição na qual os tokens são amostrados. Padrão: 1.0, Intervalo: de 0.0 a 2.0
+ **Top P** (`top_p`): limite o grupo de próximos tokens em cada etapa ao percentil N superior dos tokens possíveis, em que 1.0 significa o grupo de todos os tokens possíveis e 0.01 significa o grupo somente dos próximos tokens mais prováveis.
### Tamanho
Os modelos Jamba da AI21 Labs são compatíveis com os parâmetros a seguir para controlar o tamanho da resposta gerada.
+ **Tamanho máximo de conclusão** (`max_tokens`): o número máximo de tokens permitidos para cada mensagem de resposta gerada. Normalmente, a melhor maneira de limitar o tamanho da saída é o fornecimento de um limite de tamanho no prompt do sistema (por exemplo, “limite suas respostas a três frases”). Padrão: 4096, Intervalo: de 0 a 4096.
+ **Sequências de parada** (`stop`): encerre a mensagem quando o modelo gerar uma dessas sequências de caracteres. A sequência de parada não está incluída na mensagem gerada. Cada sequência pode ter até 64K de comprimento e conter novas linhas como caracteres \$1n.
Exemplos:
+ String de parada única com uma palavra e um ponto final: “macacos”.
+ Várias strings de parada e uma nova linha: [“gato”, “cachorro”, “ . ”, “\$1\$1\$1\$1”, “\$1n”]
+ **Número de respostas** (`n`): quantas respostas de chat devem ser geradas. As observações n devem ser 1 para respostas de streaming. Se n for definido como maior que 1, a configuração de `temperature=0` sempre falhará porque é garantido que todas as respostas sejam duplicadas. Padrão: 1, Intervalo: de 1 a 16
### Repetições
Os modelos Jamba da AI21 Labs são compatíveis com os parâmetros a seguir para controlar repetição na resposta gerada.
+ **Penalidade de frequência** (`frequency_penalty`): reduza a frequência de palavras repetidas em uma única mensagem de resposta aumentando esse número. Essa penalidade aumenta gradualmente quanto mais vezes uma palavra aparece durante a geração da resposta. A definição como 2.0 produzirá uma string com poucas ou nenhuma palavra repetida.
+ **Penalidade de presença** (`presence_penalty`): reduza a frequência de palavras repetidas em uma única mensagem aumentando esse número. Ao contrário da penalidade de frequência, a penalidade de presença é a mesma, não importa quantas vezes uma palavra apareça.
## Campo do corpo da solicitação de invocação do modelo
Ao fazer uma chamada [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) usando um modelo da AI21 Labs, preencha o campo `body` com um objeto JSON que esteja em conformidade com o modelo a seguir. Insira o prompt no campo `prompt`.
```
{
"messages": [
{
"role":"system", // Non-printing contextual information for the model
"content":"You are a helpful history teacher. You are kind and you respond with helpful content in a professional manner. Limit your answers to three sentences. Your listener is a high school student."
},
{
"role":"user", // The question we want answered.
"content":"Who was the first emperor of rome?"
}
],
"n":1 // Limit response to one answer
}
```
## Campo do corpo da resposta de invocação do modelo
Para obter informações sobre o formato do campo `body` na resposta, consulte [https://docs.ai21.com/reference/jamba-instruct-api\$1response-details](https://docs.ai21.com/reference/jamba-instruct-api#response-details).
## Exemplo de código
Este exemplo mostra como chamar o modelo *Jamba-Instruct da AI21 Labs*.
**`invoke_model`**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.invoke_model(
modelId='ai21.jamba-instruct-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
**converse**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.converse(
modelId='ai21.jamba-instruct-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
## Exemplo de código do Jamba 1.5 Large
Este exemplo mostra como chamar o modelo *Jamba 1.5 Large da AI21 Labs*.
**`invoke_model`**
```
POST https://bedrock-runtime.us-east-1.amazonaws.com/model/ai21.jamba-1-5-mini-v1:0/invoke-model HTTP/1.1
{
"messages": [
{
"role": "system",
"content": "You are a helpful chatbot with a background in earth sciences and a charming French accent."
},
{
"role": "user",
"content": "What are the main causes of earthquakes?"
}
],
"max_tokens": 512,
"temperature": 0.7,
"top_p": 0.9,
"stop": ["###"],
"n": 1
}
```
# Modelos da Cohere
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Cohere. Use essas informações para fazer chamadas de inferência a modelos da Cohere com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da Cohere. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da Cohere específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da Cohere, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da Cohere, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS esses modelos da Cohere estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da Cohere, inclua um prompt no modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para obter informações de prompts específicos da Cohere, consulte o [Cohere prompt engineering guide](https://txt.cohere.com/how-to-train-your-pet-llm-prompt-engineering).
**Topics**
+ [Modelos Command da Cohere](model-parameters-cohere-command.md)
+ [Modelos Embed e Cohere Embed v4 da Cohere](model-parameters-embed.md)
+ [Modelos Command R e Command R\$1 da Cohere](model-parameters-cohere-command-r-plus.md)
# Modelos Command da Cohere
Para solicitações de inferência a um modelo Command da Cohere, use [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
**Topics**
+ [Solicitação e reposta](#model-parameters-cohere-command-request-response)
+ [Exemplo de código](#api-inference-examples-cohere-command)
## Solicitação e reposta
------
#### [ Request ]
Os modelos Command da Cohere têm os parâmetros de inferência a seguir.
```
{
"prompt": string,
"temperature": float,
"p": float,
"k": float,
"max_tokens": int,
"stop_sequences": [string],
"return_likelihoods": "GENERATION|ALL|NONE",
"stream": boolean,
"num_generations": int,
"logit_bias": {token_id: bias},
"truncate": "NONE|START|END"
}
```
Veja a seguir os parâmetros necessários.
+ **prompt**: (obrigatório) o texto de entrada que serve como ponto de partida para gerar a resposta.
Veja os limites de texto por chamada e por caracteres.
**Textos por chamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
Veja a seguir os parâmetros opcionais.
+ **return\$1likelihoods**: especifique como e se as probabilidades do token são retornadas com a resposta. É possível especificar as opções a seguir.
+ `GENERATION`: somente as probabilidades de retorno dos tokens gerados.
+ `ALL`: probabilidades de devolução de todos os tokens.
+ `NONE`: (padrão) não retornar nenhuma probabilidade.
+ **stream**: (obrigatório para compatibilidade com streaming) especifique `true` para retornar a resposta fragmento por fragmento em tempo real e `false` para retornar a resposta completa após a conclusão do processo.
+ **logit\$1bias**: evita que o modelo gere tokens indesejados ou incentiva o modelo a incluir os tokens desejados. O formato é `{token_id: bias}`, em que o desvio é uma flutuação entre -10 e 10. Os tokens podem ser obtidos de texto que usa qualquer serviço de tokenização, como o endpoint Tokenize da Cohere. Para obter mais informações, consulte a [documentação da Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations**: o número máximo de gerações que o modelo deve retornar.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate**: especifica como a API lida com entradas maiores que o tamanho máximo do token. Use uma das seguintes opções:
+ `NONE`: retorna um erro quando a entrada excede o tamanho máximo do token de entrada.
+ `START`: descartar o início da entrada.
+ `END`: (padrão) descartar o final da entrada.
Se você especificar `START` ou `END`, o modelo descartará a entrada até que a entrada restante tenha exatamente o tamanho máximo do token de entrada do modelo.
+ **temperature**: use um valor menor para reduzir a randomização na resposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **P**: Top P. Use um valor menor para ignorar opções menos prováveis. Defina como 0 ou 1,0 para desabilitar. Se `p` e `k` estiverem habilitados, `p` agirá depois de `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k**: Top K. Especifique o número de opções de token que o modelo usa para gerar o próximo token. Se `p` e `k` estiverem habilitados, `p` agirá depois de `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens**: especifique o número máximo de tokens a serem usados na resposta gerada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences**: configure até quatro sequências que o modelo reconhece. Depois de uma sequência de parada, o modelo para de gerar mais tokens. O texto retornado não contém a sequência de parada.
------
#### [ Response ]
A resposta tem os campos possíveis a seguir:
```
{
"generations": [
{
"finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
"id": string,
"text": string,
"likelihood" : float,
"token_likelihoods" : [{"token" : string, "likelihood": float}],
"is_finished" : true | false,
"index" : integer
}
],
"id": string,
"prompt": string
}
```
+ `generations`: uma lista dos resultados gerados junto com as probabilidades dos tokens solicitados. (Sempre devolvido). Cada objeto de geração na lista contém os campos a seguir.
+ `id`: um identificador para a geração. (Sempre é retornado.)
+ `likelihood`: a probabilidade da saída. O valor é a média das probabilidades do token em `token_likelihoods`. Será retornado se você especificar o parâmetro de entrada `return_likelihoods`.
+ `token_likelihoods`: uma matriz de probabilidades por token. Será retornado se você especificar o parâmetro de entrada `return_likelihoods`.
+ `finish_reason`: o motivo pelo qual o modelo concluiu a geração de tokens. `COMPLETE`: o modelo enviou de volta uma resposta finalizada. `MAX_TOKENS`: a resposta foi cortada porque o modelo atingiu o número máximo de tokens para o tamanho do contexto. `ERROR `: algo deu errado ao gerar a resposta. `ERROR_TOXIC`: o modelo gerou uma resposta que foi considerada tóxica. `finish_reason` é retornado somente quando `is_finished` é igual a `true`. (Nem sempre é retornado).
+ `is_finished`: um campo booliano usado somente quando `stream` é `true`, indicando se há ou não tokens adicionais que serão gerados como parte da resposta de streaming. (Nem sempre é retornado)
+ `text` o texto gerado.
+ `index`: em uma resposta de streaming, use para determinar a qual geração um determinado token pertence. Quando apenas uma resposta é transmitida, todos os tokens pertencem à mesma geração e o índice não é retornado. Portanto, o `index` só é retornado em uma solicitação de streaming com um valor de `num_generations` maior que um.
+ `prompt`: o prompt da solicitação de entrada (sempre é retornado).
+ `id`: um identificador para a solicitação (sempre retornado).
Para obter mais informações, consulte [Generate](https://docs.cohere.com/reference/generate-1) na documentação da Cohere.
------
## Exemplo de código
Este exemplo mostra como chamar o modelo *Command da Cohere*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
accept = 'application/json'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated text with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-text-v14'
prompt = """Summarize this dialogue:
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
try:
body = json.dumps({
"prompt": prompt,
"max_tokens": 200,
"temperature": 0.6,
"p": 1,
"k": 0,
"num_generations": 2,
"return_likelihoods": "GENERATION"
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
generations = response_body.get('generations')
for index, generation in enumerate(generations):
print(f"Generation {index + 1}\n------------")
print(f"Text:\n {generation['text']}\n")
if 'likelihood' in generation:
print(f"Likelihood:\n {generation['likelihood']}\n")
print(f"Reason: {generation['finish_reason']}\n\n")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos Embed e Cohere Embed v4 da Cohere
Você faz solicitações de inferência a um modelo Embed com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) O ID do modelo que deseja usar é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
**nota**
O Amazon Bedrock não permite respostas de streaming dos modelos Embed da Cohere.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
O Cohere Embed v4 é um modelo de incorporação multimodal que comporta entradas de texto e imagem. Ele pode processar conteúdo intercalado de texto e imagem, o que o torna ideal para aplicações de compreensão de documentos, pesquisa visual e recuperação multimodal. O modelo comporta vários tipos de incorporação, como formatos float, int8, uint8, binário e ubinário, com dimensões de saída configuráveis de 256 a 1.536.
O ID de modelo do Cohere Embed v4 é `cohere.embed-v4`.
**Observações adicionais sobre o uso**
+ **Tamanho do contexto:** são aceitos aproximadamente 128 mil tokens; para RAG, fragmentos menores geralmente melhoram a recuperação e o custo.
+ **Dimensionamento da imagem:** imagens > 2.458.624 pixels têm resolução reduzida para esse tamanho; imagens com menos de 3.136 pixels são ampliadas.
+ **Entradas intercaladas:** prefira inputs.content[] para conteúdo multimodal semelhante a uma página, para que o contexto textual (p. ex., nome do arquivo, entidades) seja correlacionado à imagem.
**Topics**
+ [Solicitação e reposta](#model-parameters-embed-v4-request-response)
+ [Solicitação e resposta para diferentes input\$1types](#api-inference-examples-cohere-embed-v4)
+ [Exemplos de código](#code-examples-cohere-embed-v4)
## Solicitação e reposta
------
#### [ Request ]
Tipo de conteúdo: application/json
```
{
"input_type": "search_document | search_query | classification | clustering",
"texts": ["..."], // optional; text-only
"images": ["data:;base64,..."], // optional; image-only
"inputs": [
{ "content": [
{ "type": "text", "text": "..." },
{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }
]
}
], // optional; mixed (interleaved) text+image
"embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
"output_dimension": 256 | 512 | 1024 | 1536,
"max_tokens": 128000,
"truncate": "NONE | LEFT | RIGHT"
}
```
**Parâmetros**
+ **input\$1type**: (obrigatório) adiciona tokens especiais para distinguir casos de uso. Permitidos: `search_document`, `search_query`, `classification` e `clustering`. Para pesquisa/RAG, incorpore o corpo com `search_document` e as consultas com `search_query`.
+ **texts**: (opcional) matriz de strings a serem incorporadas. No máximo 96 por chamada. Se você usar `texts`, não envie `images` na mesma chamada.
+ **images**: (opcional) matriz de imagens data-URI em base64 para incorporar. No máximo 96 por chamada. Não envie `texts` e `images` juntos. (Use `inputs` para intercalação.)
+ **entradas** (opcional; mixed/fused modalidade) — Uma lista em que cada item tem uma lista de conteúdo de peças. Cada parte é `{ "type": "text", "text": ... }` ou `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Envie conteúdo intercalado semelhante a uma página aqui (p. ex., imagem da página em PDF \$1 legenda/metadados). Máximo de 96 itens.
+ **embedding\$1types**: (opcional) um ou mais `float`, `int8`, `uint8`, `binary` e `ubinary`. Se omitido, exibe incorporações de número flutuante.
+ **output\$1dimension**: (opcional) selecione o tamanho do vetor. Permitido: `256`, `512`, `1024` e `1536` (o padrão é `1536`, se especificado).
+ **max\$1tokens**: (opcional) limite para truncamento por objeto de entrada. O modelo comporta em torno de 128 mil tokens, no máximo, e um fragmento menor para RAG, conforme apropriado.
+ **truncate**: (opcional) como lidar com entradas de tamanho exagerado: `LEFT` descarta tokens do início; `RIGHT` descarta do final; `NONE` exibe um erro se a entrada ultrapassar o limite.
**Limites e tamanhos**
+ Itens por solicitação: até 96 imagens. O tipo de arquivo de imagem original deve estar no formato png, jpeg, webp ou gif e pode ter até 5 MB.
+ Limite de tamanho da solicitação: \$120 MB de carga útil total.
+ Máximo de tokens de entrada: 128 mil. Os arquivos de imagem são convertidos em tokens, e o total de tokens deve ser inferior a 128 mil.
+ Imagens: no máximo 2.458.624 pixels antes da redução da amostragem; imagens com menos de 3.136 pixels sobreamostradas. Forneça imagens como `data:;base64,....`
+ Contagem de tokens (por item de `inputs`): tokens de uma entrada de imagem ≈ (pixels da imagem ÷ 784) x 4 tokens de uma entrada intercalada de texto e imagem = (pixels da imagem ÷ 784) x 4 \$1 (tokens de texto).
**Dica:** Para isso PDFs, converta cada página em uma imagem e envie-a `inputs` junto com os metadados da página (por exemplo, nome\$1do\$1arquivo, entidades) em partes de texto adjacentes.
------
#### [ Response ]
Tipo de conteúdo: application/json
Se você solicitou um único tipo de incorporação (p. ex., somente `float`):
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Se você solicitou vários tipos de incorporação (por exemplo, `["float","int8"]`):
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ O número de vetores exibidos corresponde ao tamanho da matriz `texts` ou ao número de itens de `inputs`.
+ O tamanho de cada vetor é igual a `output_dimension` (o padrão é `1536`).
------
## Solicitação e resposta para diferentes input\$1types
**A) Página intercalada (imagem \$1 legenda) com vetores int8 compactos**
**Solicitação**
```
{
"input_type": "search_document",
"inputs": [
{
"content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
]
}
],
"embedding_types": ["int8"],
"output_dimension": 512,
"truncate": "RIGHT",
"max_tokens": 128000
}
```
**Resposta (truncada)**
```
{
"id": "836a33cc-61ec-4e65-afaf-c4628171a315",
"embeddings": { "int8": [[ 7, -3, ... ]] },
"response_type": "embeddings_by_type",
"inputs": [
{ "content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
] }
]
}
```
**B) Indexação de corpo somente de texto (número flutuante padrão: 1.536 dim)**
**Solicitação**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Resposta (amostra)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Exemplos de código
------
#### [ Text input ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-v4:0'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Mixed modalities ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
text = "hello world"
model_id = 'cohere.embed-v4:0'
input_type = "search_document"
image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
embedding_types = ["int8","float"]
try:
body = json.dumps({
"inputs": [
{
"content": [
{ "type": "text", "text": text },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
]
}
],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("inputs")
for i, input in enumerate(response_body.get('inputs')):
print(f"\tinput {i}: {input}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Cohere Embed v3
**Topics**
+ [Solicitação e reposta](#model-parameters-embed-v3-request-response)
+ [Exemplo de código](#api-inference-examples-cohere-embed-v3)
## Solicitação e reposta
------
#### [ Request ]
Os modelos Embed da Cohere têm os parâmetros de inferência a seguir.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Veja a seguir os parâmetros necessários.
+ **textos**: uma matriz de strings para o modelo incorporar. Para uma performance ideal, é recomendável reduzir o tamanho de cada texto para menos de 512 tokens. um token tem cerca de quatro caracteres.
Veja os limites de texto por chamada e por caracteres.
**Textos por chamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type**: preceda tokens especiais para diferenciar um tipo do outro. Não misture tipos diferentes em conjunto, exceto ao misturar tipos para pesquisa e recuperação. Nesse caso, incorpore seu corpus com o tipo `search_document` e as consultas incorporadas com o tipo `search_query`.
+ `search_document`: em casos de uso de pesquisa, use `search_document` ao codificar documentos para incorporações que você armazena em um banco de dados de vetores.
+ `search_query`: use `search_query` ao consultar o banco de dados de vetores para encontrar documentos relevantes.
+ `classification`: use `classification` ao usar incorporações como entrada para um classificador de texto.
+ `clustering`: use `clustering` para agrupar as incorporações.
+ `images`: essa é uma matriz de imagens.
+ Uma matriz de URIs de dados de imagem para o modelo incorporar. O número máximo de imagens por chamada é 1 (ou seja, o modelo comporta apenas uma entrada de imagem).
+ A imagem deve ser um URI de dados válido. A imagem deve estar no formato image/jpeg ou image/png e ter o tamanho máximo de 5 MB.
+ Somente uma das “imagens” ou um dos “textos” deve ser fornecidos.
Veja os seguintes parâmetros opcionais:
+ **truncate**: especifica como a API lida com entradas maiores que o tamanho máximo do token. Use uma das seguintes opções:
+ `NONE`: (padrão) retorna um erro quando a entrada excede o tamanho máximo do token de entrada.
+ `START`: descarta o início da entrada.
+ `END`: descarta o final da entrada.
Se você especificar `START` ou `END`, o modelo descartará a entrada até que a entrada restante tenha exatamente o tamanho máximo do token de entrada para o modelo.
+ **embedding\$1types**: especifica os tipos de incorporação que você deseja que sejam exibidos. Opcional, e o padrão é `None`, que exibe o tipo de resposta `Embed Floats`. O tipo pode ser um ou mais dos seguintes:
+ `float`: usar esse valor para retornar as incorporações flutuantes padrão.
+ `int8`: usar esse valor para retornar incorporações int8 assinadas.
+ `uint8`: usar esse valor para retornar incorporações int8 não assinadas.
+ `binary`: usar esse valor para retornar incorporações binárias assinadas.
+ `ubinary`: usar esse valor para retornar incorporações binárias não assinadas.
Para obter mais informações, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) na documentação da Cohere.
------
#### [ Response ]
A resposta `body` de uma chamada para `InvokeModel` é a seguinte:
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
A resposta do `body` tem os seguintes campos:
+ **id**: um identificador para a resposta.
+ **response\$1type**: o tipo de resposta. Esse valor é sempre `embeddings_floats`.
+ **embeddings**: uma matriz de incorporações, em que cada incorporação é uma matriz de flutuadores com 1.024 elementos. O comprimento da matriz `embeddings` será igual ao comprimento da matriz `texts` original.
+ **texts**: uma matriz contendo as entradas de texto para as quais as incorporações foram retornadas.
+ **images**: uma matriz de uma descrição para cada entrada de imagem.
Uma `image_description`image\$1description tem o seguinte formato:
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Se a imagem foi usada como entrada, o campo de resposta `“texts”` será uma matriz vazia. O contrário não é verdadeiro (isto é, quando são usados textos, não haverá `“images”` na resposta).
Para ter mais informações, consulte [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Exemplo de código
Este exemplo mostra como chamar o modelo *Embed English da Cohere*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Entrada de imagem**
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_image_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
model_id = 'cohere.embed-english-v3'
input_type = "image"
images = [get_base64_image_uri(image_file_path, image_mime_type)]
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"images": images,
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_image_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos Command R e Command R\$1 da Cohere
Você faz solicitações de inferência para modelos Command R da Cohere e Command R\$1 da Cohere com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
**dica**
Para aplicações de conversação, é recomendável usar a API Converse. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Realizar uma conversa com as operações de API Converse](conversation-inference.md).
**Topics**
+ [Solicitação e reposta](#model-parameters-cohere-command-request-response)
+ [Exemplo de código](#api-inference-examples-cohere-command-r)
## Solicitação e reposta
------
#### [ Request ]
Os modelos Command da Cohere têm os parâmetros de inferência a seguir.
```
{
"message": string,
"chat_history": [
{
"role":"USER or CHATBOT",
"message": string
}
],
"documents": [
{"title": string, "snippet": string},
],
"search_queries_only" : boolean,
"preamble" : string,
"max_tokens": int,
"temperature": float,
"p": float,
"k": float,
"prompt_truncation" : string,
"frequency_penalty" : float,
"presence_penalty" : float,
"seed" : int,
"return_prompt" : boolean,
"tools" : [
{
"name": string,
"description": string,
"parameter_definitions": {
"parameter name": {
"description": string,
"type": string,
"required": boolean
}
}
}
],
"tool_results" : [
{
"call": {
"name": string,
"parameters": {
"parameter name": string
}
},
"outputs": [
{
"text": string
}
]
}
],
"stop_sequences": [string],
"raw_prompting" : boolean
}
```
Veja a seguir os parâmetros necessários.
+ **message**: (obrigatório) entrada de texto para o modelo responder.
Veja a seguir os parâmetros opcionais.
+ **chat\$1history**: uma lista de mensagens anteriores entre o usuário e o modelo, com o objetivo de oferecer contexto conversacional ao modelo para responder à mensagem do usuário.
Estes campos são obrigatórios.
+ `role`: o perfil da mensagem. Os valores válidos são tokens `USER` ou `CHATBOT`.
+ `message`: o conteúdo do texto da mensagem.
Este é um JSON de exemplo para o campo `chat_history`
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
+ **documents**: uma lista de textos que o modelo pode citar para gerar uma resposta mais precisa. Cada documento é um dicionário de string-string. A geração resultante inclui citações que fazem referência a alguns desses documentos. É recomendável manter a contagem total de palavras das strings no dicionário abaixo de 300. Um campo `_excludes` (matriz de strings) pode ser fornecido para omitir a exibição de alguns pares de chave-valor no modelo. Para obter mais informações, consulte [Document Mode guide](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) na documentação da Cohere.
Este é um JSON de exemplo para o campo `documents`.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
+ **search\$1queries\$1only**: assume `false` como padrão. Quando `true`, a resposta só conterá uma lista de consultas de pesquisa geradas, mas nenhuma pesquisa ocorrerá e nenhuma resposta do modelo para a `message` do usuário será gerada.
+ **preamble**: substitui o preâmbulo padrão para geração das consultas de pesquisa. Não tem efeito sobre as gerações de uso de ferramentas.
+ **max\$1tokens**: o número máximo de tokens que o modelo deve gerar como parte da resposta. A definição de um valor baixo pode acarretar gerações incompletas. A definição de `max_tokens` pode acarretar gerações incompletas ou inexistentes quando usado com os campos `tools` ou `documents`.
+ **temperature**: use um valor menor para reduzir a randomização na resposta. A randomização pode ser maximizada ainda mais aumentando o valor do parâmetro `p`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **P**: Top P. Use um valor menor para ignorar opções menos prováveis.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k**: Top K. Especifique o número de opções de token que o modelo usa para gerar o próximo token.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation**: assume `OFF` como padrão. Determina como o prompt é construído. Com `prompt_truncation` definido como `AUTO_PRESERVE_ORDER`, alguns elementos de `chat_history` e `documents` serão descartados para construir um prompt que se encaixe no limite de comprimento do contexto do modelo. Durante esse processo, a ordem dos documentos e o histórico do chat serão preservados. Com `prompt_truncation` definido como `OFF`, nenhum elemento será descartado.
+ **frequency\$1penalty**: usado para reduzir a repetitividade dos tokens gerados. Quanto maior for o valor, mais forte será a penalidade aplicada aos tokens presentes anteriormente, proporcional a quantas vezes eles já apareceram no prompt ou na geração anterior.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty**: usado para reduzir a repetitividade dos tokens gerados. Semelhante a `frequency_penalty`, exceto por essa penalidade ser aplicada igualmente a todos os tokens que já apareceram, independentemente das frequências exatas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed**: se especificado, o backend fará o possível para amostrar tokens de maneira determinística, de modo que solicitações repetidas com a semente e os parâmetros iguais retornem o mesmo resultado. No entanto, o determinismo não pode ser totalmente garantido.
+ **return\$1prompt**: especifique `true` para retornar o prompt completo que foi enviado ao modelo. O valor padrão é `false`. Na resposta, o prompt no campo `prompt`.
+ **tools**: uma lista de ferramentas (funções) disponíveis que o modelo pode sugerir fazendo uma invocação antes de produzir uma resposta de texto. Quando `tools` for passado (sem `tool_results`), o campo `text` na resposta será `""` e o campo `tool_calls` na resposta será preenchido com uma lista de chamadas de ferramenta que precisam ser feitas. Se nenhuma chamada precisar ser feita, a matriz `tool_calls` permanecerá vazia.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
**dica**
É recomendável usar a API Converse para integrar o uso de ferramentas à aplicação. Para obter mais informações, consulte [Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock](tool-use.md).
Este é um JSON de exemplo para o campo `tools`.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameter_definitions": {
"sign": {
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
"type": "str",
"required": true
}
}
}
]
```
Para obter mais informações, consulte [Single-Step Tool Use (Function Calling)](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
+ **tools\$1results**: uma lista de resultados das ferramentas de invocação recomendadas pelo modelo no turno de chat anterior. Os resultados são usados para produzir uma resposta textual e são referidos em citações. Durante o uso de `tool_results`, `tools` também deve ser passado. Cada `tool_result` contém informações sobre como foi invocado, bem como uma lista de saídas em forma de dicionários. A lógica de citação exclusiva e refinada do Cohere exige que a saída seja uma lista. Se a saída for apenas um item, como `{"status": 200}`, você ainda deverá envolvê-la em uma lista.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
Este é um JSON de exemplo para o campo `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\$1sequences**: uma lista de sequências de parada. Depois que uma sequência de parada for detectada, o modelo deixará de gerar mais tokens.
+ **raw\$1prompting**: especifique `true` para enviar `message` do usuário ao modelo sem nenhum pré-processamento; do contrário, falso.
------
#### [ Response ]
A resposta tem os campos possíveis a seguir:
```
{
"response_id": string,
"text": string,
"generation_id": string,
"citations": [
{
"start": int,
"end": int,
"text": "string",
"document_ids": [
"string"
]
}
],
"finish_reason": string,
"tool_calls": [
{
"name": string,
"parameters": {
"parameter name": string
}
}
],
{
"meta": {
"api_version": {
"version": string
},
"billed_units": {
"input_tokens": int,
"output_tokens": int
}
}
}
```
+ **response\$1id**: identificador exclusivo para conclusão do chat
+ **text**: a resposta do modelo para entrada da mensagem de chat.
+ **generation\$1id**: identificador exclusivo para conclusão do chat, usado com o endpoint de feedback na plataforma da Cohere.
+ **citations**: uma matriz de citações em linha e metadados associados para a resposta gerada. Contém os seguintes campos:
+ **start**: o índice no qual a citação começa, começando em 0.
+ **end**: o índice após o qual a citação termina, começando em 0.
+ **text**: o texto ao qual a citação pertence.
+ **document\$1ids**: uma matriz de IDs de documento que correspondem aos documentos citados para o texto.
+ **prompt**: o prompt completo que foi enviado ao modelo. Especifique o campo `return_prompt` para retorná-lo.
+ **finish\$1reason**: o motivo pelo qual o modelo deixou de gerar saída. Pode ser qualquer um dos seguintes:
+ **complete**: a conclusão atingiu o final do token de geração; verifique se esse é o motivo final do melhor desempenho.
+ **error\$1toxic**: não foi possível concluir a geração por causa de nossos filtros de conteúdo.
+ **error\$1limit**: não foi possível concluir a geração porque o limite de contexto do modelo foi atingido.
+ **error**: não foi possível concluir a geração por causa de um erro.
+ **user\$1cancel**: não foi possível concluir a geração porque ela foi interrompida pelo usuário.
+ **max\$1tokens**: não foi possível concluir a geração porque o usuário especificou um limite `max_tokens` na solicitação e esse limite foi atingido. Isso talvez não acarrete o melhor desempenho.
+ **tool\$1calls**: uma lista de ferramentas indicadas para chamadas. Só retornado caso você especifique o campo de entrada `tools`.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
**dica**
É recomendável usar a API Converse para integrar o uso de ferramentas à aplicação. Para obter mais informações, consulte [Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock](tool-use.md).
Este é um JSON de exemplo para o campo `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta**: dados de uso da API (só existem para streaming).
+ `api_version`: a versão da API. A versão está no campo `version`.
+ `billed_units`: as unidades faturadas. Os valores possíveis são:
+ `input_tokens`: o número dos tokens de entrada faturados.
+ `output_tokens`: o número dos tokens de saída faturados.
------
## Exemplo de código
Este exemplo mostra como chamar o modelo *Command R da Cohere*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Cohere Command R model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere Command R model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info(
"Successfully generated text with Cohere Command R model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-r-v1:0'
chat_history = [
{"role": "USER", "message": "What is an interesting new role in AI if I don't have an ML background?"},
{"role": "CHATBOT", "message": "You could explore being a prompt engineer!"}
]
message = "What are some skills I should have?"
try:
body = json.dumps({
"message": message,
"chat_history": chat_history,
"max_tokens": 2000,
"temperature": 0.6,
"p": 0.5,
"k": 250
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
response_chat_history = response_body.get('chat_history')
print('Chat history\n------------')
for response_message in response_chat_history:
if 'message' in response_message:
print(f"Role: {response_message['role']}")
print(f"Message: {response_message['message']}\n")
print("Generated text\n--------------")
print(f"Stop reason: {response_body['finish_reason']}")
print(f"Response text: \n{response_body['text']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos da DeepSeek
DeepSeek[Os modelos R1 e V3.1 da são text-to-text modelos disponíveis para uso em inferência por meio da API Invoke ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) e da API Converse (Converse e). [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
Ao fazer chamadas de inferência com modelos da DeepSeek, você precisa incluir um prompt para o modelo. Para ter informações gerais sobre como criar prompts para os modelos da DeepSeek compatíveis com o Amazon Bedrock, consulte o [guia de prompts da DeepSeek](https://api-docs.deepseek.com/guides/reasoning_model.html).
**nota**
Você não pode remover o acesso solicitado dos modelos Amazon Titan, Amazon Nova, DeepSeek -R1, Mistral AI, Meta Llama 3 Instruct e Meta Llama 4. É possível impedir que os usuários façam chamadas de inferência a esses modelos usando uma política do IAM e especificando o ID do modelo. Para ter mais informações [Negar acesso para inferência de modelos de base](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference .html).
Para obter uma qualidade de resposta ideal comDeepSeek-R1, limite o `max_tokens` parâmetro a 8.192 tokens ou menos. Embora a API aceite até 32.768 tokens, a qualidade da resposta diminui significativamente acima de 8.192 tokens. Isso se alinha aos recursos de raciocínio do modelo, conforme descrito no guia de raciocínio de [inferência.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html)
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da DeepSeek. Use essas informações para fazer chamadas de inferência para DeepSeek modelos com a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operação. Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da DeepSeek.
Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Como esse modelo é invocado por meio de inferência entre regiões, você precisará usar o [ID do perfil de inferência](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) como o ID do modelo. Por exemplo, para os EUA, você usará o `us.deepseek.r1-v1:0`.
+ Nome do modelo: DeepSeek-R1.
+ Modelo de texto
Para obter mais informações sobre como usar DeepSeek modelos com APIs, consulte [DeepSeekModelos](https://deepseek.com/).
**Solicitação e reposta do DeepSeek**
**Corpo da solicitação**
DeepSeektem os seguintes parâmetros de inferência para uma chamada de inferência de conclusão de texto.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_tokens": int,
"stop": string array
}
```
**Campos:**
+ **prompt**: (string) entrada de texto obrigatória do prompt.
+ **temperature**: (número flutuante) valor numérico menor ou igual a 1.
+ **top\$1p**: (número flutuante) valor numérico menor ou igual a 1.
+ **max\$1tokens** — (int) Tokens usados, mínimo de 1 a um máximo de 8.192 tokens para uma qualidade ideal. Embora a API aceite até 32.768 tokens, a qualidade da resposta diminui significativamente acima de 8.192 tokens.
+ **stop**: (matriz de strings) no máximo dez itens.
**Corpo de resposta**
A DeepSeek tem os parâmetros de resposta a seguir para uma chamada de inferência de preenchimento de texto. Este exemplo é um preenchimento de texto do DeepSeek e não exibe um bloco de raciocínio de conteúdo.
```
{
"choices": [
{
"text": string,
"stop_reason": string
}
]
}
```
**Campos:**
+ **stop\$1reason**: (string) o motivo pelo qual a resposta parou de gerar texto. Valor de `stop` ou `length`.
+ **stop**: (string) o modelo parou de gerar texto para o prompt de entrada.
+ **length**: (string) o tamanho dos tokens do texto gerado excede o valor de `max_tokens` na chamada a `InvokeModel` (ou a `InvokeModelWithResponseStream`, se você estiver transmitindo uma saída). A resposta é truncada ao atingir `max_tokens`. Aumente o valor de `max_tokens` e tente fazer sua solicitação novamente.
**Código de exemplo**
Este exemplo mostra como chamar o modelo DeepSeek-R1.
```
# Use the API to send a text message to DeepSeek-R1.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Região da AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the cross Region inference profile ID for DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in DeepSeek-R1's instruction format.
formatted_prompt = f"""
<｜begin▁of▁sentence｜><｜User｜>{prompt}<｜Assistant｜>\n
"""
body = json.dumps({
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
"top_p": 0.9,
})
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=body)
# Read the response body.
model_response = json.loads(response["body"].read())
# Extract choices.
choices = model_response["choices"]
# Print choices.
for index, choice in enumerate(choices):
print(f"Choice {index + 1}\n----------")
print(f"Text:\n{choice['text']}\n")
print(f"Stop reason: {choice['stop_reason']}\n")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
**Converse**
Corpo da solicitação: use este exemplo de corpo de solicitação para chamar a API Converse.
```
{
"modelId": string, # us.deepseek.r1-v1:0
"system": [
{
"text": string
}
],
"messages": [
{
"role": string,
"content": [
{
"text": string
}
]
}
],
"inferenceConfig": {
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": string array
},
"guardrailConfig": {
"guardrailIdentifier":"string",
"guardrailVersion": "string",
"trace": "string"
}
}
```
**Campos:**
+ **system**: (opcional) o prompt do sistema para a solicitação.
+ **messages**: (obrigatório) as mensagens de entrada.
+ **role**: o perfil do turno da conversa. Os valores válidos são `user` e `assistant`.
+ **content**: (obrigatório) o conteúdo do turno da conversa, como uma matriz de objetos. Cada objeto contém um campo de tipo, no qual você pode especificar um dos seguintes valores:
+ **text**: (obrigatório) se você especificar esse tipo, deverá incluir um campo de texto e especificar o prompt de texto como o respectivo valor.
+ **inferenceConfig**
+ **temperature**: (opcional) valor mínimo = 0 e máximo = 1.
+ **topP**: (opcional) valor mínimo = 0 e máximo = 1.
+ **maxTokens**: (opcional) o número máximo de tokens a serem gerados antes de parar. Valores: mínimo = 0 e máximo = 32.768.
+ **stopSequences**: (opcional) sequências de texto personalizadas que farão com que o modelo pare de gerar saída. Máximo = 10 itens.
Corpo da resposta: use este exemplo de corpo de resposta para chamar a API Converse.
```
{
"message": {
"role" : "assistant",
"content": [
{
"text": string
},
{
"reasoningContent": {
"reasoningText": string
}
}
],
},
"stopReason": string,
"usage": {
"inputTokens": int,
"outputTokens": int,
"totalTokens": int
}
"metrics": {
"latencyMs": int
}
}
```
**Campos:**
+ **message**: a resposta dada pelo modelo.
+ **role**: a função conversacional da mensagem gerada. O valor é sempre `assistant`.
+ **content**: o conteúdo gerado pelo modelo, que é exibido como uma matriz. Existem dois tipos de conteúdo:
+ **text**: o conteúdo textual da resposta.
+ **reasoningContent**: (opcional) o conteúdo do raciocínio da resposta do modelo.
+ **reasoningText**: o texto do raciocínio da resposta do modelo.
+ **stopReason**: o motivo pelo qual o modelo parou de gerar a resposta.
+ **end\$1turn**: o modelo atingiu um ponto de parada natural.
+ **max\$1tokens**: o texto gerado excedeu o valor do campo de entrada `maxTokens` ou o número máximo de tokens que o modelo permite.
Código de exemplo - Aqui está um exemplo de como DeepSeek fazer uma chamada para a ConverseAPI.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with DeepSeek-R1 (on demand).
"""
import logging
import boto3
from botocore.client import Config
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
system_prompts,
messages):
"""
Sends messages to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
system_prompts (JSON) : The system prompts for the model to use.
messages (JSON) : The messages to send to the model.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Inference parameters to use.
temperature = 0.5
max_tokens = 4096
# Base inference parameters to use.
inference_config = {
"temperature": temperature,
"maxTokens": max_tokens,
}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
)
# Log token usage.
token_usage = response['usage']
logger.info("Input tokens: %s", token_usage['inputTokens'])
logger.info("Output tokens: %s", token_usage['outputTokens'])
logger.info("Total tokens: %s", token_usage['totalTokens'])
logger.info("Stop reason: %s", response['stopReason'])
return response
def main():
"""
Entrypoint for DeepSeek-R1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "us.deepseek.r1-v1:0"
# Setup the system prompts and messages to send to the model.
system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist."}]
message_1 = {
"role": "user",
"content": [{"text": "Create a list of 3 pop songs."}]
}
message_2 = {
"role": "user",
"content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
}
messages = []
try:
# Configure timeout for long responses if needed
custom_config = Config(connect_timeout=840, read_timeout=840)
bedrock_client = boto3.client(service_name='bedrock-runtime', config=custom_config)
# Start the conversation with the 1st message.
messages.append(message_1)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
# Add the response message to the conversation.
output_message = response['output']['message']
# Remove reasoning content from the response
output_contents = []
for content in output_message["content"]:
if content.get("reasoningContent"):
continue
else:
output_contents.append(content)
output_message["content"] = output_contents
messages.append(output_message)
# Continue the conversation with the 2nd message.
messages.append(message_2)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
output_message = response['output']['message']
messages.append(output_message)
# Show the complete conversation.
for message in messages:
print(f"Role: {message['role']}")
for content in message['content']:
if content.get("text"):
print(f"Text: {content['text']}")
if content.get("reasoningContent"):
reasoning_content = content['reasoningContent']
reasoning_text = reasoning_content.get('reasoningText', {})
print()
print(f"Reasoning Text: {reasoning_text.get('text')}")
print()
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
# Modelos da Luma AI
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Luma AI. Use essas informações para fazer chamadas de inferência para modelos de IA do Luma com a [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)operação. Esta seção também inclui exemplos de código Python que mostram como chamar modelos da Luma AI. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário.
+ ID do modelo: luma.ray-v 2:0
+ Nome do modelo: Luma Ray 2
+ Modelo de conversão de texto em vídeo
O Luma AI modela solicitações do modelo de processo de forma assíncrona usando o Async APIs , incluindo, e. [StartAsyncInvoke[GetAsyncInvoke[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
O modelo da Luma AI processa prompts usando as etapas a seguir.
+ O usuário solicita o modelo usando [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html).
+ Espere até InvokeJob que termine. Você pode usar `GetAsyncInvoke` ou `ListAsyncInvokes` para verificar o status de conclusão da tarefa.
+ A saída do modelo será colocada no bucket de saída especificado do Amazon S3.
Para obter mais informações sobre como usar os modelos Luma AI com o APIs, consulte [Geração de vídeo](https://docs.lumalabs.ai/docs/video-generation).
Chamada de inferência da Luma AI.
```
POST /async-invoke HTTP/1.1
Content-type: application/json
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "your input text here",
"aspect_ratio": "16:9",
"loop": false,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Campos**
+ **prompt**: (string) o conteúdo necessário no vídeo de saída (1 <= tamanho <= 5 mil caracteres).
+ **aspect\$1ratio**: (enumeração) a proporção do vídeo de saída (“1:1”, “16:9”, “9:16”, “4:3”, “3:4”, “21:9”, “9:21”).
+ **loop**: (booliano) se o vídeo de saída deve ser repetido.
+ **duration**: (enumeração) a duração do vídeo de saída (“5 s”, “9 s”).
+ **resolution**: (enumeração) a resolução do vídeo de saída (“540p”, “720p”).
O MP4 arquivo será armazenado no bucket do Amazon S3 conforme configurado na resposta.
## Text-to-Video Geração
Gere vídeos com base em prompts de texto usando o modelo Luma Ray 2. O modelo oferece várias opções de personalização, como proporção, duração, resolução e loop.
** Text-to-VideoSolicitação básica**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Avançado Text-to-Video com opções**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit",
"aspect_ratio": "16:9",
"loop": true,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
** Text-to-VideoExemplo adicional**
Exemplo com parâmetros de resolução e duração.
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "a car",
"resolution": "720p",
"duration": "5s"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
## Image-to-Video Geração
Transforme imagens estáticas em vídeos dinâmicos fornecendo quadros-chave. É possível especificar quadros iniciais, quadros finais ou ambos para controlar o processo de geração de vídeo.
**Básico Image-to-Video com Start Frame**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
}
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Image-to-Video com quadros inicial e final**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
},
"frame1": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
},
"loop": false,
"aspect_ratio": "16:9"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Parâmetros adicionais para Image-to-Video**
+ **quadros-chave** — (objeto) Define quadros-chave de início (quadro0) e and/or fim (quadro1)
+ **frame0**: imagem do quadro-chave inicial.
+ **frame1**: imagem do quadro-chave final.
+ **type**: deve ser “imagem”.
+ **source**: fonte da imagem.
## Solução de problemas
Problemas e soluções comuns ao trabalhar com modelos da Luma AI:
+ **Status de trabalho “Failed”**: verifique se o bucket do S3 tem as permissões de gravação adequadas e se o bucket existe na mesma região do serviço Bedrock.
+ **Erros de acesso ao URL** da imagem - Certifique-se de que a imagem URLs esteja acessível ao público e use HTTPS. As imagens devem estar nos formatos compatíveis (JPEG ou PNG).
+ **Erros de parâmetros inválidos**: verifique se os valores das proporções correspondem às opções permitidas (“1:1”, “16:9”, “9:16”, “4:3”, “3:4”, “21:9”, “9:21”) e a duração é “5 s” ou “9 s”.
+ **Problemas de tempo limite**: use `GetAsyncInvoke` para verificar o status do trabalho em vez de esperar de forma síncrona. A geração de vídeo pode levar alguns minutos.
+ **Erros de tamanho do prompt**: mantenha os prompts com 1 a 5 mil caracteres. Prompts mais longos serão rejeitados.
## Observações sobre desempenho
Considerações importantes sobre o desempenho e as limitações do modelo da Luma AI:
+ **Tempo de processamento**: a geração de vídeo normalmente leva de 2 a 5 minutos para vídeos de 5 segundos e de 4 a 8 minutos para vídeos de 9 segundos, dependendo da complexidade.
+ **Requisitos de imagem**: as imagens de entrada devem ser de alta qualidade, com resolução mínima de 512 x 512 pixels. O tamanho máximo de imagem permitido é de 4.096 x 4096 pixels.
+ **Tamanho do vídeo de saída**: os vídeos gerados variam de 5 MB a 50 MB, dependendo da duração, resolução e complexidade do conteúdo.
+ **Limites de taxa**: as chamadas de API assíncronas estão sujeitas a cotas de serviço. Monitore seu uso e solicite aumentos de cota, se necessário.
+ **Armazenamento do S3**: garanta capacidade de armazenamento suficiente do S3 para vídeos de saída e considere a possibilidade de utilizar políticas de ciclo de vida para otimizar os custos.
## Documentação relacionada
Para ter informações adicionais e saber mais sobre serviços relacionados:
+ **Configuração do Amazon S3**: [Criar buckets do S3](https://docs.aws.amazon.com/s3/latest/userguide/creating-buckets-s3.html) e [políticas de bucket](https://docs.aws.amazon.com/s3/latest/userguide/bucket-policies.html) para armazenamento de saída.
+ **Operações de API assíncronas** - [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html), [GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html), e referência de [ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)API.
+ **Cotas de serviço**: [Cotas do Amazon Bedrock](quotas.md), para se informar sobre solicitações de aumento de limites e cotas de serviço do Bedrock.
+ **Práticas recomendadas de processamento de vídeo**: [Envie prompts e gere respostas com a inferência de modelo](inference.md), para obter orientação geral sobre inferência de modelos.
+ **Documentação da Luma AI**: [geração de vídeo da Luma Labs](https://docs.lumalabs.ai/docs/video-generation), para conhecer recursos detalhados do modelo e recursos avançados.
# Modelos Llama da Meta
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos Llama da Meta. Use essas informações para fazer chamadas de inferência a modelos Llama da Meta com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos Llama da Meta. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo Llama da Meta específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos Llama da Meta, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos Llama da Meta, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS esses modelos Llama da Meta estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos Llama da Meta, inclua um prompt para o modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para obter informações de prompts específicos do Llama da Meta, consulte o [MetaLlama prompt engineering guide](https://ai.meta.com/llama/get-started/#prompting).
**nota**
Os modelos Llama 3.2 Instruct e Llama 3.3 Instruct usam cercas geográficas. Isso significa que esses modelos não podem ser usados fora das regiões da AWS disponíveis para esses modelos listados na tabela Regiões.
Esta seção fornece informações sobre como usar os modelos da Meta a seguir.
+ Llama 3 Instruct
+ Llama 3.1 Instruct
+ Llama 3.2 Instruct
+ Llama 3.3 Instruct
+ Llama 4 Instruct
**Topics**
+ [Solicitação e reposta](#model-parameters-meta-request-response)
+ [Código de exemplo](#api-inference-examples-meta-llama)
## Solicitação e reposta
O corpo da solicitação é enviado no campo `body` de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**nota**
Não é possível usar as operações (streaming) [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) ou [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html) (streaming) com o Llama 4 Instruct.
------
#### [ Request ]
Os modelos Llama 3 Instruct, Llama 3.1 Instruct, Llama 3.2 Instruct e Llama 4 Instruct têm os seguintes parâmetros de inferência:
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_gen_len": int
}
```
OBSERVAÇÃO: os modelos Llama 3.2 e posteriores adicionam `images` à estrutura da solicitação, que é uma lista de strings. Exemplo: `images: Optional[List[str]]`
Os seguintes parâmetros são obrigatórios:
+ **prompt**: (obrigatório) o prompt que você deseja passar para o modelo. Para obter os melhores resultados, formate a conversa com o modelo a seguir.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Modelo de exemplo com prompt do sistema**
Veja a seguir um exemplo de prompt que inclui um prompt do sistema.
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
You are a helpful AI assistant for travel tips and recommendations<|eot_id|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Exemplo de conversa de vários turnos**
Veja a seguir um exemplo de prompt de uma conversa de vários turnos.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
The capital of France is Paris!<|eot_id|><|start_header_id|>user<|end_header_id|>
What is the weather like in Paris?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Modelo de exemplo com prompt do sistema**
Para ter mais informações, consulte [Meta Llama 3](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3).
Veja os seguintes parâmetros opcionais:
+ **temperature**: use um valor menor para reduzir a randomização na resposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-meta.html)
+ **top\$1p**: use um valor menor para ignorar opções menos prováveis. Defina como 0 ou 1,0 para desabilitar.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-meta.html)
+ **max\$1gen\$1len**: especifique o número máximo de tokens a serem usados na resposta gerada. O modelo trunca a resposta quando o texto gerado excede `max_gen_len`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-meta.html)
------
#### [ Response ]
Os modelos Llama 3 Instruct exibem os campos a seguir para uma chamada de inferência de preenchimento de texto.
```
{
"generation": "\n\n",
"prompt_token_count": int,
"generation_token_count": int,
"stop_reason" : string
}
```
Mais informações sobre cada campo são fornecidas a seguir.
+ **generation**: o texto gerado.
+ **prompt\$1token\$1count**: o número de tokens no prompt.
+ **generation\$1token\$1count**: o número de tokens no texto gerado.
+ **stop\$1reason**: o motivo pelo qual a resposta parou de gerar texto. Os valores possíveis são:
+ **interromper**: o modelo terminou de gerar texto para o prompt de entrada.
+ **comprimento**: o comprimento dos tokens do texto gerado excede o valor de `max_gen_len` na chamada para `InvokeModel` (`InvokeModelWithResponseStream`, se você estiver transmitindo uma saída). A resposta é truncada em tokens `max_gen_len`. Considere aumentar o valor de `max_gen_len` e tente novamente.
------
## Código de exemplo
Este exemplo mostra como chamar o modelo *Llama 3 Instruct*.
```
# Use the native inference API to send a text message to Meta Llama 3.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Região da AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["generation"]
print(response_text)
```
Este exemplo mostra como controlar a duração da geração usando modelos Llama 3 Instruct. Para obter respostas detalhadas ou resumos, ajuste “max\$1gen\$1len” e inclua instruções específicas no prompt.
# Modelos da Mistral AI
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Mistral AI. Use essas informações para fazer chamadas de inferência a modelos da Mistral AI com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da Mistral AI. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da Mistral AI específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da Mistral AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da Mistral AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS esses modelos da Mistral AI estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da Mistral AI, inclua um prompt no modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para obter informações de prompts específicos da Mistral AI, consulte o [Mistral AI prompt engineering guide](https://docs.mistral.ai/guides/prompting_capabilities/).
**Topics**
+ [Text Completion da Mistral AI](model-parameters-mistral-text-completion.md)
+ [Conclusão de chat da Mistral AI](model-parameters-mistral-chat-completion.md)
+ [Parâmetros e inferência do Large (24.07) da Mistral AI](model-parameters-mistral-large-2407.md)
+ [Parâmetros e inferência do Pixtral Large (25.02)](model-parameters-mistral-pixtral-large.md)
# Text Completion da Mistral AI
A API Text Completion da Mistral AI permite gerar texto com um modelo da Mistral AI.
Você faz solicitações de inferência a modelos da Mistral AI com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming).
Os modelos da Mistral AI estão disponíveis sob a [licença do Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obter mais informações sobre o uso dos modelos da Mistral AI, consulte a [documentação da Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatíveis](#mistral--text-completion-supported-models)
+ [Solicitação e reposta](#model-parameters-mistral-text-completion-request-response)
+ [Exemplo de código](#api-inference-examples-mistral-text-completion)
## Modelos compatíveis
É possível usar os modelos Mistral AI a seguir.
+ Mistral 7B Instruct
+ Mixtral 8X7B Instruct
+ Mistral Large
+ Mistral Small
É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
## Solicitação e reposta
------
#### [ Request ]
Os modelos da Mistral AI têm os parâmetros de inferência a seguir.
```
{
"prompt": string,
"max_tokens" : int,
"stop" : [string],
"temperature": float,
"top_p": float,
"top_k": int
}
```
Veja a seguir os parâmetros necessários.
+ **prompt**: (obrigatório) o prompt que você deseja enviar ao modelo, conforme mostrado no exemplo a seguir.
```
[INST] What is your favourite condiment? [/INST]
```
O exemplo a seguir mostra como formatar um prompt com vários turnos.
```
[INST] What is your favourite condiment? [/INST]
Well, I'm quite partial to a good squeeze of fresh lemon juice.
It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!
[INST] Do you have mayonnaise recipes? [/INST]
```
O texto do perfil do usuário está dentro dos tokens `[INST]...[/INST]`, o texto externo é o perfil do assistente. O início e o final de uma string são representados pelos tokens `` (início da string) e `` (final da string). Para obter informações sobre como enviar um prompt de chat no formato correto, consulte os [modelos de chat](https://docs.mistral.ai/models/#chat-template) na documentação da Mistral AI.
Veja a seguir os parâmetros opcionais.
+ **max\$1tokens**: especifique o número máximo de tokens a serem usados na resposta gerada. O modelo trunca a resposta quando o texto gerado excede `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **stop**: uma lista de sequências de parada que, se geradas pelo modelo, impedem que o modelo gere mais resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **temperature**: controla a randomização das previsões feitas pelo modelo. Para obter mais informações, consulte [Geração de resposta de influência com parâmetros de inferência](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1p**: controla a diversidade do texto gerado pelo modelo ao definir a porcentagem de candidatos mais prováveis que o modelo considera para o próximo token. Para obter mais informações, consulte [Geração de resposta de influência com parâmetros de inferência](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top-k**: controla o número de candidatos mais prováveis que o modelo considera para o próximo token. Para obter mais informações, consulte [Geração de resposta de influência com parâmetros de inferência](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
------
#### [ Response ]
A resposta `body` de uma chamada para `InvokeModel` é a seguinte:
```
{
"outputs": [
{
"text": string,
"stop_reason": string
}
]
}
```
A resposta do `body` tem os seguintes campos:
+ **outputs**: uma lista de saídas do modelo. Cada saída tem os campos a seguir.
+ **text**: o texto gerado pelo modelo.
+ **stop\$1reason**: o motivo pelo qual a resposta parou de gerar texto. Os valores possíveis são:
+ **interromper**: o modelo terminou de gerar texto para o prompt de entrada. O modelo para porque não tem mais conteúdo para gerar ou se o modelo gerar uma das sequências de parada que você define no parâmetro de solicitação `stop`.
+ **length**: o tamanho dos tokens do texto gerado excede o valor de `max_tokens` na chamada a `InvokeModel` (`InvokeModelWithResponseStream`, se você estiver transmitindo uma saída). A resposta é truncada em tokens `max_tokens`.
------
## Exemplo de código
Este exemplo mostra como chamar o modelo Mistral 7B Instruct.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Mistral AI model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Mistral AI model.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
JSON: The response from the model.
"""
logger.info("Generating text with Mistral AI model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info("Successfully generated text with Mistral AI model %s", model_id)
return response
def main():
"""
Entrypoint for Mistral AI example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
model_id = 'mistral.mistral-7b-instruct-v0:2'
prompt = """[INST] In Bash, how do I list all text files in the current directory
(excluding subdirectories) that have been modified in the last month? [/INST]"""
body = json.dumps({
"prompt": prompt,
"max_tokens": 400,
"temperature": 0.7,
"top_p": 0.7,
"top_k": 50
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
outputs = response_body.get('outputs')
for index, output in enumerate(outputs):
print(f"Output {index + 1}\n----------")
print(f"Text:\n{output['text']}\n")
print(f"Stop reason: {output['stop_reason']}\n")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating text with Mistral AI model {model_id}.")
if __name__ == "__main__":
main()
```
# Conclusão de chat da Mistral AI
A API de conclusão de chat da Mistral AI permite criar aplicações de conversação.
**dica**
É possível usar a API de conclusão de chat da Mistral AI com as operações de inferência de base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). No entanto, é recomendável usar a API Converse para implementar mensagens em sua aplicação. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Realizar uma conversa com as operações de API Converse](conversation-inference.md).
Os modelos da Mistral AI estão disponíveis sob a [licença do Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obter mais informações sobre o uso dos modelos da Mistral AI, consulte a [documentação da Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatíveis](#mistral-supported-models-chat-completion)
+ [Solicitação e reposta](#model-parameters-mistral-chat-completion-request-response)
## Modelos compatíveis
É possível usar os modelos Mistral AI a seguir.
+ Mistral Large
É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
## Solicitação e reposta
------
#### [ Request ]
Os modelos da Mistral AI têm os parâmetros de inferência a seguir.
```
{
"messages": [
{
"role": "system"|"user"|"assistant",
"content": str
},
{
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": str,
"function": {
"name": str,
"arguments": str
}
}
]
},
{
"role": "tool",
"tool_call_id": str,
"content": str
}
],
"tools": [
{
"type": "function",
"function": {
"name": str,
"description": str,
"parameters": dict
}
}
],
"tool_choice": "auto"|"any"|"none",
"max_tokens": int,
"top_p": float,
"temperature": float
}
```
Veja a seguir os parâmetros necessários.
+ **messages**: (obrigatório) as mensagens que você deseja passar para o modelo.
+ **role**: o perfil da mensagem. Os valores válidos são:
+ **system**: define o comportamento e o contexto do modelo na conversação.
+ **user**: a mensagem do usuário a ser enviada ao modelo.
+ **assistant**: a resposta do modelo.
+ **content**: o conteúdo da mensagem.
```
[
{
"role": "user",
"content": "What is the most popular song on WZPZ?"
}
]
```
Para passar o resultado de uma ferramenta, use JSON com os campos a seguir.
+ **role**: o perfil da mensagem. O valor deve ser `tool`.
+ **tool\$1call\$1id**: o ID da solicitação da ferramenta. Você obtém o ID dos campos `tool_calls` na resposta da solicitação anterior.
+ **content**: o resultado da ferramenta.
O exemplo a seguir é o resultado de uma ferramenta que obtém a música mais tocada em uma estação de rádio.
```
{
"role": "tool",
"tool_call_id": "v6RMMiRlT7ygYkT4uULjtg",
"content": "{\"song\": \"Elemental Hotel\", \"artist\": \"8 Storey Hike\"}"
}
```
Veja a seguir os parâmetros opcionais.
+ **tools**: definições de ferramentas que o modelo pode usar.
Se você incluir `tools` em sua solicitação, o modelo poderá exibir um campo `tool_calls` na mensagem que representa o uso dessas ferramentas pelo modelo. É possível executar essas ferramentas usando a entrada de ferramenta gerada pelo modelo e, opcionalmente, retornar os resultados ao modelo usando blocos de conteúdo de `tool_result`.
O exemplo a seguir é de uma ferramenta que obtém as músicas mais tocadas em uma estação de rádio.
```
[
{
"type": "function",
"function": {
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameters": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
}
]
```
+ **tool\$1choice**: especifica como os perfis são chamados. Se definido como `none`, o modelo não chamará um perfil e, em vez disso, gerará uma mensagem. Se definido como `auto`, o modelo poderá optar por gerar uma mensagem ou chamar um perfil. Se definido como `any`, o modelo será forçado a chamar um perfil.
+ **max\$1tokens**: especifique o número máximo de tokens a serem usados na resposta gerada. O modelo trunca a resposta quando o texto gerado excede `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **temperature**: controla a randomização das previsões feitas pelo modelo. Para obter mais informações, consulte [Geração de resposta de influência com parâmetros de inferência](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **top\$1p**: controla a diversidade do texto gerado pelo modelo ao definir a porcentagem de candidatos mais prováveis que o modelo considera para o próximo token. Para obter mais informações, consulte [Geração de resposta de influência com parâmetros de inferência](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
------
#### [ Response ]
A resposta `body` de uma chamada para `InvokeModel` é a seguinte:
```
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": str,
"tool_calls": [...]
},
"stop_reason": "stop"|"length"|"tool_calls"
}
]
}
```
A resposta do `body` tem os seguintes campos:
+ **choices**: a saída dos campos do modelo.
+ **index**: o índice da mensagem.
+ **message**: a mensagem do modelo.
+ **role**: o perfil da mensagem.
+ **content**: o conteúdo da mensagem.
+ **tool\$1calls**: se o valor de `stop_reason` for `tool_calls`, esse campo conterá uma lista de solicitações de ferramentas que o modelo deseja que você execute.
+ **id**: o ID da solicitação da ferramenta.
+ **function**: a função que o modelo está solicitando.
+ **name**: o nome da função.
+ **arguments**: os argumentos a serem passados para a ferramenta
Veja um exemplo de solicitação de uma ferramenta que obtém as músicas mais tocadas em uma estação de rádio.
```
[
{
"id": "v6RMMiRlT7ygYkT4uULjtg",
"function": {
"name": "top_song",
"arguments": "{\"sign\": \"WZPZ\"}"
}
}
]
```
+ **stop\$1reason**: o motivo pelo qual a resposta parou de gerar texto. Os valores possíveis são:
+ **interromper**: o modelo terminou de gerar texto para o prompt de entrada. O modelo para porque não tem mais conteúdo para gerar ou se o modelo gerar uma das sequências de parada que você define no parâmetro de solicitação `stop`.
+ **length**: o tamanho dos tokens do texto gerado excede o valor de `max_tokens`. A resposta é truncada em tokens `max_tokens`.
+ **tool\$1calls**: o modelo está solicitando que você execute uma ferramenta.
------
# Parâmetros e inferência do Large (24.07) da Mistral AI
A API de conclusão de chat da Mistral AI permite criar aplicações de conversação. Você também pode usar a API Converse do Amazon Bedrock com esse modelo. É possível usar ferramentas para fazer chamadas de função.
**dica**
É possível usar a API de conclusão de chat da Mistral AI com as operações de inferência de base ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). No entanto, é recomendável usar a API Converse para implementar mensagens em sua aplicação. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Realizar uma conversa com as operações de API Converse](conversation-inference.md).
Os modelos da Mistral AI estão disponíveis sob a [licença do Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Para obter mais informações sobre o uso dos modelos da Mistral AI, consulte a [documentação da Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatíveis](#mistral-supported-models-chat-completion)
+ [Exemplos de solicitação e resposta](#model-parameters-mistral-large-2407-request-response)
## Modelos compatíveis
É possível usar os modelos da Mistral AI a seguir com os exemplos de código nesta página.
+ Mistral Large 2 (24.07)
É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
## Exemplos de solicitação e resposta
------
#### [ Request ]
Exemplo de modelo de invocação do Large (24.07) da Mistral AI.
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model(
modelId='mistral.mistral-large-2407-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ Converse ]
Exemplo de conversão do Large (24.07) da Mistral AI.
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.converse(
modelId='mistral.mistral-large-2407-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Exemplo de invoke\$1model\$1with\$1response\$1stream do Large (24.07) da Mistral AI.
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model_with_response_stream(
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French cheese?"}],
}),
"modelId":"mistral.mistral-large-2407-v1:0"
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Exemplo de converse\$1stream example do Large (24.07) da Mistral AI.
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"messages": [{
"role": "user","content": [{"text": "What is the best French cheese? "}]
}],
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.converse_stream(**mistral_params)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage ... ")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
```
------
#### [ JSON Output ]
Exemplo de saída JSON do Large (24.07) da Mistral AI.
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Exemplo de ferramentas do Large (24.07) da Mistral AI.
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Parâmetros e inferência do Pixtral Large (25.02)
O Pixtral Large 25.02 é um modelo multimodal de 124B de parâmetros que combina a compreensão da state-of-the-art imagem com poderosos recursos de processamento de texto. AWS é o primeiro provedor de nuvem a oferecer o Pixtral Large (25.02) como um modelo totalmente gerenciado e sem servidor. Esse modelo oferece desempenho de última geração para realizar tarefas de análise de documentos, interpretação de gráficos e compreensão de imagens naturais, mantendo os recursos avançados de texto do Mistral Large 2.
Com uma janela de contexto de 128K, o Pixtral Large 25.02 alcança best-in-class desempenho nos principais benchmarks, incluindo DocVQA e. MathVista VQAv2 O modelo oferece suporte multilíngue abrangente em vários idiomas e é treinado em mais de oitenta linguagens de programação. Os principais recursos incluem raciocínio matemático avançado, chamada de função nativa, saída JSON e sólida adesão ao contexto para aplicações de RAG.
A API de conclusão de chat da Mistral AI permite criar aplicações de conversação. Você também pode usar a API Converse do Amazon Bedrock com esse modelo. É possível usar ferramentas para fazer chamadas de função.
**dica**
Você pode usar a API de conclusão de Mistral AI bate-papo com as operações básicas de inferência ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)). No entanto, é recomendável usar a API Converse para implementar mensagens em sua aplicação. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Realizar uma conversa com as operações de API Converse](conversation-inference.md).
O modelo Pixtral Large da Mistral AI está disponível sob a [Licença de Pesquisa da Mistral](https://mistral.ai/licenses/MRL-0.1.md). Para obter mais informações sobre o uso dos modelos da Mistral AI, consulte a [documentação da Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modelos compatíveis](#mistral-supported-models-chat-completion)
+ [Exemplos de solicitação e resposta](#model-parameters-pixtral-large-2502-request-response)
## Modelos compatíveis
É possível usar os modelos da Mistral AI a seguir com os exemplos de código nesta página.
+ Pixtral Large (25.02)
É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
## Exemplos de solicitação e resposta
------
#### [ Request ]
Exemplo de modelo de invocação do Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
print(json.dumps(json.loads(response.get('body').read()), indent=4))
```
------
#### [ Converse ]
Exemplo de conversão do Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
print(json.dumps(response.get('output'), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Exemplo de invoke\$1model\$1with\$1response\$1stream do Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model_with_response_stream(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Exemplo de converse\$1stream do Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse_stream(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage ... ")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
```
------
#### [ JSON Output ]
Exemplo de saída JSON do Pixtral Large (25.02).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Exemplo de ferramentas do Pixtral Large (25.02).
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Modelos da OpenAI
A OpenAI oferece os seguintes modelos de peso aberto:
+ [https://huggingface.co/openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b): um modelo menor otimizado para menor latência e casos de uso locais ou especializados.
+ [https://huggingface.co/openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b): um modelo maior otimizado para casos de uso de produção e uso geral ou de alto raciocínio.
A seguinte tabela a seguir resume informações sobre os modelos:
| Informações | gpt-oss-20b | gpt-oss-120b |
| --- | --- | --- |
| Data de lançamento | 5 de agosto de 2025 | 5 de agosto de 2025 |
| ID do modelo | openai.gpt-oss-20b-1:0 | openai.gpt-oss-120b-1:0 |
| ID do produto | N/D | N/D |
| Modalidades de entrada aceitas | Texto | Texto |
| Modalidades de saída aceitas | Texto | Texto |
| Janela de contexto | 128.000 | 128.000 |
Os modelos da OpenAI são compatíveis com os seguintes recursos:
+ [Invocação de modelos](inference.md) com as seguintes operações:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
+ [API Chat Completions da OpenAI](inference-chat-completions.md)
+ [Inferência em lote](batch-inference.md) com [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html).
+ Aplicação de [barreiras de proteção](guardrails.md) por meio do uso de cabeçalhos nas operações de invocação de modelo.
**Topics**
+ [Corpo da solicitação da OpenAI](#model-parameters-openai-request)
+ [Corpo da resposta da OpenAI](#model-parameters-openai-response)
+ [Exemplo de uso de modelos da OpenAI](#model-parameters-openai-use)
## Corpo da solicitação da OpenAI
Para ter informações sobre os parâmetros no corpo da solicitação e as respectivas descrições, consulte [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) na documentação da OpenAI.
Use os campos do corpo da solicitação das seguintes maneiras:
+ Em uma solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou de conclusão do OpenAI Chat, inclua os campos no corpo da solicitação.
+ Em uma solicitação [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), faça o seguinte:
+ Mapeie as `messages` da seguinte maneira:
+ Para cada mensagem cuja função é`developer`, adicione `content` a [SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)na `system` matriz.
+ Para cada mensagem cuja função é `user` ou`assistant`, adicione `content` a a [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)no `content` campo e especifique a `role` no `role` campo de uma [Mensagem](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) na `messages` matriz.
+ Associe os valores dos seguintes campos aos campos correspondentes no objeto `inferenceConfig`:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-openai.html)
+ Inclua qualquer outro campo no objeto `additionalModelRequestFields`.
**Considerações ao criar o corpo da solicitação**
+ Os modelos da OpenAI permitem somente entrada e saída de texto.
+ O valor no campo `model` deve corresponder ao do cabeçalho. Você pode omitir esse campo para permitir que ele seja preenchido automaticamente com o mesmo valor do cabeçalho.
+ O valor no campo `stream` deve corresponder à operação de API que você usa. Você pode omitir esse campo para permitir que ele seja preenchido automaticamente com o valor correto.
+ Se você usar [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), o `stream` valor deve ser`false`.
## Corpo da resposta da OpenAI
O corpo da resposta dos modelos da OpenAI está em conformidade com o objeto de preenchimento de chat apresentado pela OpenAI. Para ter mais informações sobre os campos de resposta, consulte [The chat completion object](https://platform.openai.com/docs/api-reference/chat/object) na documentação da OpenAI.
**nota**
Se você usar `InvokeModel`, o raciocínio do modelo, circundado pelas tags ``, precederá o conteúdo do texto da resposta.
## Exemplo de uso de modelos da OpenAI
Esta seção apresenta alguns exemplos de como usar os modelos da OpenAI.
### Pré-requisitos
Antes de testar estes exemplos, verifique se você atendeu a estes pré-requisitos:
+ **Autenticação** — Você pode se autenticar com suas AWS credenciais ou com uma chave de API Amazon Bedrock.
Configure suas AWS credenciais ou gere uma chave de API Amazon Bedrock para autenticar sua solicitação.
+ Para saber mais sobre como configurar suas AWS credenciais, consulte [Acesso programático com credenciais de AWS segurança](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html).
+ Para saber mais sobre as chaves de API do Amazon Bedrock e como gerá-las, consulte a seção Chaves de API no capítulo Build.
**nota**
Se você usar a API Chat Completions da OpenAI, só poderá se autenticar com uma chave de API do Amazon Bedrock.
+ **Endpoint** — Encontre o endpoint que corresponde à AWS região a ser usada nos [endpoints e cotas do Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se você usa um AWS SDK, talvez precise especificar apenas o código da região e não o endpoint inteiro ao configurar o cliente. Você deve usar um endpoint associado a uma região compatível com o modelo usado no exemplo.
+ **Acesso ao modelo**: solicite acesso a um modelo da OpenAI. Para obter mais informações, consulte [Gerencie o acesso ao modelo usando SDK e CLI](model-access.md#model-access-modify).
+ **(Se o exemplo usar um SDK) Instale o SDK** — Após a instalação, configure as credenciais padrão e uma região padrão. AWS Se você não configurar credenciais padrão ou uma região, precisará especificá-las explicitamente nos exemplos de código pertinentes. Para obter mais informações sobre provedores de credenciais padronizados, consulte [Ferramentas AWS SDKs e provedores de credenciais padronizados](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
**nota**
Se você usar o SDK da OpenAI, só poderá se autenticar com uma chave de API do Amazon Bedrock e deverá definir explicitamente o endpoint do Amazon Bedrock.
Expanda a seção do exemplo que você deseja ver:
### Create chat completion da OpenAI
Para ver exemplos de uso da API Create chat completion da OpenAI, escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
O seguinte script Python chama a API Create chat completion com o SDK para Python da OpenAI:
```
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1",
api_key="$AWS_BEARER_TOKEN_BEDROCK" # Replace with actual API key
)
completion = client.chat.completions.create(
model="openai.gpt-oss-20b-1:0",
messages=[
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
)
print(completion.choices[0].message)
```
------
#### [ HTTP request using curl ]
Você pode executar o seguinte comando em um terminal para chamar a API Create chat completion usando curl:
```
curl -X POST https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
```
------
### InvokeModel
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Python ]
```
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Model ID
model_id = 'openai.gpt-oss-20b-1:0'
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
# Make the InvokeModel request
response = client.invoke_model(
modelId=model_id,
body=json.dumps(native_request)
)
# Parse and print the message for each choice in the chat completion
response_body = json.loads(response['body'].read().decode('utf-8'))
for choice in response_body['choices']:
print(choice['message']['content'])
```
------
### Converse
Ao usar a API [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) unificada, você precisa associar os campos de Create chat completion da OpenAI ao campo correspondente no corpo da solicitação de Converse.
Por exemplo, compare o corpo da solicitação de preenchimento de chat a seguir com o corpo da solicitação Converse correspondente:
------
#### [ Create chat completion request body ]
```
{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7
}
```
------
#### [ Converse request body ]
```
{
"messages": [
{
"role": "user",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
],
"system": [
{
"text": "You are a helpful assistant."
}
],
"inferenceConfig": {
"maxTokens": 150,
"temperature": 0.7
}
}
```
------
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Python ]
```
# Use the Conversation API to send a text message to Anthropic Claude.
import boto3
from botocore.exceptions import ClientError
# Initialize the Bedrock Runtime client
client = boto3.client("bedrock-runtime")
# Set the model ID
model_id = "openai.gpt-oss-20b-1:0"
# Set up messages and system message
messages = [
{
"role": "assistant",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
]
system = [
{
"text": "You are a helpful assistant."
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=messages,
system=system,
inferenceConfig={
"maxTokens": 150,
"temperature": 0.7,
"topP": 0.9
},
)
# Extract and print the response text.
for content_block in response["output"]["message"]["content"]:
print(content_block)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
------
### Guardrails com InvokeModel
Aplique uma barreira de proteção ao executar a invocação do modelo especificando o ID da barreira de proteção, a versão e se deve ou não habilitar o rastreamento da barreira de proteção no cabeçalho de uma solicitação de invocação do modelo.
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import json
# Initiate the Amazon Bedrock Runtime client
bedrock_runtime = boto3.client("bedrock-runtime")
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values from your guardrail
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
try:
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=json.dumps(native_request),
guardrailIdentifier=guardrail_id,
guardrailVersion=guardrail_version,
trace='ENABLED',
)
response_body = json.loads(response.get('body').read())
print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
print(json.dumps(response_body, indent=2))
except ClientError as err:
print("RequestId = " + err.response['ResponseMetadata']['RequestId'])
raise err
```
------
### Barreiras de proteção com preenchimentos de chat da OpenAI
Para ver exemplos de uso de barreiras de proteção com preenchimentos de chat da OpenAI, escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ OpenAI SDK (Python) ]
```
import openai
from openai import OpenAIError
# Endpoint for Amazon Bedrock Runtime
bedrock_endpoint = "https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values
bedrock_api_key = "$AWS_BEARER_TOKEN_BEDROCK"
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
client = openai.OpenAI(
api_key=bedrock_api_key,
base_url=bedrock_endpoint,
)
try:
response = client.chat.completions.create(
model=model_id,
# Specify guardrail information in the header
extra_headers={
"X-Amzn-Bedrock-GuardrailIdentifier": guardrail_id,
"X-Amzn-Bedrock-GuardrailVersion": guardrail_version,
"X-Amzn-Bedrock-Trace": "ENABLED",
},
# Additional guardrail information can be specified in the body
extra_body={
"amazon-bedrock-guardrailConfig": {
"tagSuffix": "xyz" # Used for input tagging
}
},
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
]
)
request_id = response._request_id
print(f"Request ID: {request_id}")
print(response)
except OpenAIError as e:
print(f"An error occurred: {e}")
if hasattr(e, 'response') and e.response is not None:
request_id = e.response.headers.get("x-request-id")
print(f"Request ID: {request_id}")
```
------
#### [ OpenAI SDK (Java) ]
```
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponseFor;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
// Endpoint for Amazon Bedrock Runtime
String bedrockEndpoint = "http://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
// Model ID
String modelId = "openai.gpt-oss-20b-1:0"
// Replace with actual values
String bedrockApiKey = "$AWS_BEARER_TOKEN_BEDROCK"
String guardrailId = "GR12345"
String guardrailVersion = "DRAFT"
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(bedrockApiKey)
.baseUrl(bedrockEndpoint)
.build()
ChatCompletionCreateParams request = ChatCompletionCreateParams.builder()
.addUserMessage("What is the temperature in Seattle?")
.model(modelId)
// Specify additional headers for the guardrail
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailIdentifier", guardrailId)
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailVersion", guardrailVersion)
// Specify additional body parameters for the guardrail
.putAdditionalBodyProperty(
"amazon-bedrock-guardrailConfig",
JsonValue.from(Map.of("tagSuffix", JsonValue.of("xyz"))) // Allows input tagging
)
.build();
HttpResponseFor rawChatCompletionResponse =
client.chat().completions().withRawResponse().create(request);
final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();
System.out.println(chatCompletion);
```
------
### Inferência em lote
A [inferência em lote](batch-inference.md) permite executar a inferência do modelo de forma assíncrona com vários prompts. Para executar a inferência em lote com um modelo da OpenAI, faça o seguinte:
1. Crie um arquivo JSONL e preencha-o com pelo menos o número mínimo de objetos JSON, cada um separado por uma nova linha. Cada objeto `modelInput` deve corresponder ao formato do corpo da solicitação de [preenchimento de chat da OpenAI](https://platform.openai.com/docs/api-reference/chat/create). Veja a seguir um exemplo das duas primeiras linhas de um arquivo JSONL contendo corpos de solicitação para a OpenAI.
```
{
"recordId": "RECORD1",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Can you generate a question with a factual answer?"
}
],
"max_completion_tokens": 1000
}
}
{
"recordId": "RECORD2",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 1000
}
}
...
```
**nota**
O campo `model` é opcional porque o serviço de inferência em lote o inserirá para você com base no cabeçalho, caso você o omita.
Verifique se o arquivo JSONL está de acordo com as cotas de inferência em lote, conforme descrito em [Formatar e carregar os dados de inferência](batch-inference-data.md).
1. Faça upload do arquivo para um bucket do Amazon S3.
1. Envie uma [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html)solicitação com um [endpoint do plano de controle Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-cp) com o bucket S3 da etapa anterior especificada no `inputDataConfig` campo e do OpenAI modelo especificado no campo. `modelId`
Para obter um exemplo de end-to-end código, consulte[Exemplo de código para inferência em lote](batch-inference-example.md). Substitua pelas configurações adequadas para os modelos da OpenAI.
# Modelos da Stability AI
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Stability AI. Use essas informações para fazer chamadas de inferência para modelos de IA de estabilidade com a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operação. Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da Stability AI. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da Stability AI específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da Stability AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da Stability AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais AWS regiões os modelos de IA de estabilidade estão disponíveis, consulte[Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da Stability AI, inclua um prompt para o modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para ter informações sobre prompts específicos da Stability AI, consulte o [guia de engenharia de prompts da Stability AI](https://platform.stability.ai/docs/getting-started).
## Modelos e serviços de imagem compatíveis
O Amazon Bedrock é compatível com os modelos e serviços de imagem da Stability AI a seguir.
**nota**
O suporte a todos os outros modelos da Stability AI está em processo de descontinuação.
| Modelo | Casos de uso | Exemplo |
| --- | --- | --- |
| [Imagem estável Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma marca de luxo usa o Stable Image Ultra para criar elementos visuais deslumbrantes de sua coleção mais recente para revistas, garantindo uma percepção premium que corresponde aos seus elevados padrões. |
| [Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma equipe de desenvolvimento de jogos usa SD3 .5 Large para criar texturas ambientais detalhadas e conceitos de personagens, acelerando seu fluxo criativo. |
| [Núcleo de imagem estável](model-parameters-diffusion-stable-image-core-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Um varejista on-line usa o Stable Image Core para gerar rapidamente imagens de produtos para recém-chegados, permitindo que ele liste itens com mais rapidez e mantenha seu catálogo. up-to-date |
| [Stability AI Image Services](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma empresa de mídia usa pesquisa e recoloração, transferência de estilo e remoção de plano de fundo para gerar variações de imagens para uma campanha publicitária. |
**Topics**
+ [Modelos e serviços de imagem compatíveis](#supported-stability-models)
+ [Solicitação e resposta do Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md)
+ [Stable Diffusion 3.5 Large da Stability AI](model-parameters-diffusion-3-5-large.md)
+ [Solicitação e resposta do Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Stability AI Image Services](stable-image-services.md)
# Solicitação e resposta do Stable Image Ultra
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operação.
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stable Image Ultra, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campo de corpo de respostas de invocação do modelo**
Ao fazer uma chamada `InvokeModel` usando um modelo Stable Image Ultra, a resposta é semelhante à mostrada a seguir.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Uma resposta com um motivo final que não seja `null` terá a seguinte aparência:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
O modelo Stability.ai Stable Image Ultra tem os seguintes parâmetros de inferência para uma chamada de text-to-image inferência.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionais**
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **modo** — Defina como text-to-image. Padrão: text-to-image. Enum: `text-to-image`.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
#### [ Image to image ]
O modelo Stability.ai Stable Image Ultra tem os seguintes parâmetros de inferência para uma chamada de image-to-image inferência.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionais**
+ **image**: (string) a imagem em base64 a ser usada como ponto de partida para a geração. Formatos compatíveis: JPEG, PNG e WebP.
+ **strength**: (número) nível de influência do parâmetro de imagem sobre a imagem gerada. Imagens com valores de intensidade mais baixos serão mais parecidas com a imagem original. Intervalo: de 0,0 a 1,0. Padrão: 0,35.
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stable Diffusion 3.5 Large da Stability AI
O modelo Stable Diffusion 3.5 Large usa 8 bilhões de parâmetros e suporta saída de resolução de 1 megapixel para geração text-to-image e image-to-image geração.
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stable Diffusion 3.5 Large, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
+ **prompt**: (string) descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Campo de corpo de respostas de invocação do modelo**
Ao fazer uma chamada `InvokeModel` usando um modelo Stable Diffusion 3.5 Large, a resposta é semelhante à mostrada abaixo.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Uma resposta com um motivo final que não seja `null` terá a seguinte aparência:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
------
#### [ Text to image ]
O modelo Stability.ai Stable Diffusion 3.5 Large tem os seguintes parâmetros de inferência para uma chamada de text-to-image inferência.
+ **prompt** (string) — Descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Parâmetros opcionais**
+ **aspect\$1ratio** (string) — Controla a proporção da imagem gerada. Válido somente para text-to-image solicitações. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Padrão 1:1.
+ **mode** (string) (GenerationMode) - Padrão: text-to-image. Enum: image-to-image ou text-to-image. Controla se é uma image-to-image geração text-to-image ou, o que afeta quais parâmetros são necessários:
+ text-to-image requer somente o parâmetro prompt.
+ image-to-image requer os parâmetros de alerta, imagem e intensidade.
+ **semente** (número) — Valor para controlar a aleatoriedade na geração. Varia de 0 a 4.294.967.295. Padrão: 0 (propagação aleatória).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texto descrevendo elementos a serem excluídos da imagem de saída. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato da imagem de saída. Enumeração: jpeg, png, webp. Padrão: png.
```
import boto3
import json
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
```
------
#### [ Image to image ]
O modelo Stability.ai Stable Diffusion 3.5 Large tem os seguintes parâmetros de inferência para uma chamada de image-to-image inferência.
+ **prompt** (string) — Descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **image** (string) — Imagem de entrada codificada em Base64. Mínimo de 64 pixels por lado. Formatos compatíveis: jpeg, png e webp.
+ **mode** (string) (GenerationMode) - Padrão: text-to-image. Enum: image-to-image ou text-to-image. Controla se é uma image-to-image geração text-to-image ou, o que afeta quais parâmetros são necessários:
+ text-to-image requer somente o parâmetro prompt.
+ image-to-image requer os parâmetros de alerta, imagem e intensidade.
+ **força** (número) — Controla a influência da imagem de entrada na saída. Varia de 0 a 1. O valor 0 preserva a imagem de entrada e o valor 1 ignora a imagem de entrada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **semente** (número) — Valor para controlar a aleatoriedade na geração. Varia de 0 a 4.294.967.295. Padrão: 0 (propagação aleatória).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texto descrevendo elementos a serem excluídos da imagem de saída. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato da imagem de saída. Enumeração: jpeg, png, webp. Padrão: png.
```
import boto3
import base64
import json
# Load and encode image
with open('input_image.jpg', 'rb') as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.',
'image': image_base64,
'strength': 0.7
})
)
```
------
# Solicitação e resposta do Stable Image Core
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stability AI Stable Diffusion Stable Image Core, preencha o campo do corpo com um objeto JSON semelhante ao mostrado abaixo.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo de corpo de respostas de invocação do modelo**
Quando você faz uma InvokeModel chamada usando um modelo Stability AI Stable Diffusion Stable Image Core, a resposta se parece com a seguinte
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
O modelo Stable Image Core tem os parâmetros de inferência a seguir para uma chamada de inferência de texto para imagem.
**text\$1prompts** (obrigatório): uma matriz de prompts de texto a serem usados na geração. Cada elemento é um objeto JSON que contém um prompt e um peso para o prompt.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Campos opcionais**
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.stable-image-core-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability AI Image Services
Você pode usar o Stability AI Image Services com o Amazon Bedrock para acessar treze ferramentas especializadas de edição de imagens projetadas para acelerar fluxos de trabalho criativos profissionais. Com o Stability AI Image Services, você pode gerar imagens com base em um esboço, reestruturar e aplicar um novo estilo em uma imagem existente ou remover e substituir objetos dentro de uma imagem.
Esta seção descreve como fazer chamadas de inferência para Stability AI Image Services usando o. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Ela também oferece exemplos de código em Python e exemplos de imagens antes e depois do uso do Stability AI Image Services.
O Stability AI Image Services está disponível nas seguintes categorias:
+ **Edição**: serviços de edição de imagem baseados em IA, como preenchimento com máscaras (preenchimento generativo) ou com palavras. Inclui ferramentas para colocação de produtos e publicidade, bem como ferramentas básicas, como remoção de plano de fundo.
+ **Controle**: pode receber prompts, mapas e outros guias. Esses serviços utilizam ControlNets tecnologias similares baseadas em modelos de difusão estável.
**nota**
A assinatura de qualquer edição ou controle do Stability AI Image Service inscreve você automaticamente em todos os treze Stability AI Image Services disponíveis.
**Topics**
+ [Solicitação e reposta](#model-parameters-stable-image-services-request-response)
+ [Sofisticado](#stable-image-services-upscale)
+ [Edição](#stable-image-services-edit)
+ [Controle](#stable-image-services-control)
## Solicitação e reposta
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando o Stability AI Image Services, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo de corpo de respostas de invocação do modelo**
Quando você faz uma InvokeModel chamada usando o Stability AI Image Services, a resposta se parece com a seguinte
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Sofisticado
A seção a seguir descreve os sofisticados Stability AI Image Services.
### Luxo criativo
O Creative Upscale captura imagens entre 64x64 e 1 megapixel e as aprimora para a resolução 4K. Esse serviço pode aprimorar as imagens em 20 a 40 vezes, preservando e, muitas vezes, aprimorando a qualidade. O Creative Upscale funciona melhor em imagens altamente degradadas e não serve para fotos de 1 megapixel ou mais, pois realiza reimaginações pesadas.
O Creative Upscale tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels deve estar entre 4.096 e 1.048.576 pixels. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao aprimorar uma imagem. Valores mais altos resultarão na adição de mais detalhes à imagem durante o aumento de escala. Intervalo entre 0,1 e 0,5. Padrão 0.3
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação da Creative Upscale usando o seguinte prompt: *Essa arte digital onírica captura um pássaro vibrante e caleidoscópico em uma* floresta tropical exuberante.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Alto padrão conservador
O Conservative Upscale captura imagens entre 64x64 e 1 megapixel e as aprimora para resolução 4K. Esse serviço pode aprimorar as imagens em 20 a 40 vezes, preservando todos os aspectos. O Conservative Upscale minimiza as alterações na imagem e não deve ser usado para reimaginar uma imagem.
O Conservative Upscale tem os seguintes parâmetros necessários:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao aprimorar uma imagem. Valores mais altos resultarão na adição de mais detalhes à imagem durante o aumento de escala. Intervalo entre 0,1 e 0,5. Padrão 0,35
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação da Conservative Upscale usando o seguinte prompt: *foto de uma galinha gigante em uma floresta*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### Aumento rápido
O Fast Upscale melhora a resolução da imagem em 4 vezes usando IA preditiva e generativa. Esse serviço leve e rápido é ideal para aprimorar a qualidade das imagens compactadas, tornando-o adequado para postagens em mídias sociais e outros aplicativos.
O Fast Upscale tem os seguintes parâmetros necessários:
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. A largura deve estar entre 32 e 1.536 pixels. A altura deve estar entre 32 e 1.536 pixels. A contagem total de pixels deve estar entre 1.024 e 1.048.576 pixels. Formatos compatíveis: jpeg, png e webp.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação Fast Upscale.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Edição
A seção a seguir descreve a edição do Stability AI Image Services.
### Preencher
O recurso preencher modifica imagens de forma inteligente preenchendo ou substituindo áreas especificadas por um novo conteúdo com base no conteúdo de uma imagem de máscara.
O preenchimento tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 à qual aplicar o preenchimento. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **mask**: (string) controla a intensidade do processo de preenchimento por pixel, seja por meio de uma segunda imagem (transmitida para esse parâmetro) ou por meio do canal alfa do parâmetro de imagem.
+ **Transmissão de uma máscara**: a imagem transmitida para esse parâmetro deve ser uma imagem em preto e branco que represente, em qualquer pixel, a intensidade do preenchimento com base em quão escuro ou claro é o pixel em questão. Os pixels totalmente pretos não representam a intensidade do preenchimento, enquanto os pixels totalmente brancos representam a intensidade máxima. Caso a máscara tenha um tamanho diferente do parâmetro da imagem, ela será redimensionada automaticamente.
+ **Suporte ao canal alfa**: se você não fornecer uma máscara explícita, uma será derivada do canal alfa do parâmetro de imagem. Os pixels transparentes serão preenchidos enquanto os pixels opacos serão preservados. Caso uma imagem com um canal alfa seja fornecida com uma máscara, a máscara terá precedência.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de preenchimento.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Pintura externa
O Outpaint insere conteúdo adicional em uma imagem para preencher o espaço em qualquer direção. Em comparação com outras tentativas automáticas ou manuais de expandir o conteúdo em uma imagem, o serviço Outpaint minimiza as indicações de que a imagem original foi editada.
O Outpaint tem os seguintes parâmetros necessários:
+ **image** ‐ (string) A imagem Base64 a ser pintada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
**nota**
Pelo menos uma direção de pintura: (esquerda, direita, para cima ou para baixo) deve ser fornecida com um valor diferente de zero. Para obter resultados de melhor qualidade, considere a composição e o conteúdo da imagem original ao escolher as direções de pintura.
Os seguintes parâmetros são opcionais:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao pintar uma imagem. Valores mais altos resultarão na adição de mais conteúdo criativo à imagem durante a pintura. Intervalo entre 0,1 e 1,0. Padrão: 0,5.
+ **left** ‐ (inteiro) O número de pixels a serem pintados no lado esquerdo da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **right** ‐ (inteiro) O número de pixels a serem pintados no lado direito da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **up** ‐ (inteiro) O número de pixels a serem pintados na parte superior da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **down** ‐ (inteiro) O número de pixels a serem pintados na parte inferior da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação Outpaint.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Pesquisar e recolorir
Pesquisar e recolorir permite que você altere a cor de um objeto específico em uma imagem usando um prompt. Esse serviço é uma versão específica do preenchimento que não requer máscara. Ele segmentará automaticamente o objeto e a aplicará uma nova cor usando as cores solicitadas no prompt.
Pesquisar e recolorir tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 que deve ser colorida novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **select\$1prompt**: (string) breve descrição do que pesquisar na imagem. Máximo de 10 mil caracteres.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de pesquisa e recoloração usando o seguinte prompt: *pink jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Pesquisar e substituir
Pesquisar e substituir permite que você use um prompt de pesquisa em linguagem simples para identificar um objeto a ser substituído. O serviço segmentará automaticamente o objeto e o substituirá pelo objeto solicitado no prompt sem precisar de uma máscara.
Pesquisar e substituir tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 que deve ser colorida novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **search\$1prompt**: (string) breve descrição sobre onde aplicar preenchimento na imagem. Máximo de 10 mil caracteres.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de pesquisa e substituição usando o seguinte prompt: *jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Apagar
Apagar permite que você remova elementos indesejados usando máscaras de imagem e mantenha a consistência do plano de fundo de forma inteligente.
Apagar tem os seguintes parâmetros obrigatórios:
+ **image**: (string) a imagem em base64 a ser apagada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **mask**: (string) controla a intensidade do processo de preenchimento por pixel, seja por meio de uma segunda imagem (transmitida para esse parâmetro) ou por meio do canal alfa do parâmetro de imagem.
+ **Transmissão de uma máscara**: a imagem transmitida para esse parâmetro deve ser uma imagem em preto e branco que represente, em qualquer pixel, a intensidade do preenchimento com base em quão escuro ou claro é o pixel em questão. Os pixels totalmente pretos não representam a intensidade do preenchimento, enquanto os pixels totalmente brancos representam a intensidade máxima. Caso a máscara tenha um tamanho diferente do parâmetro da imagem, ela será redimensionada automaticamente.
+ **Suporte ao canal alfa**: se você não fornecer uma máscara explícita, uma será derivada do canal alfa do parâmetro de imagem. Os pixels transparentes serão preenchidos enquanto os pixels opacos serão preservados. Caso uma imagem com um canal alfa seja fornecida com uma máscara, a máscara terá precedência.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
**nota**
Para obter os melhores resultados de apagamento, a máscara de definir com precisão as áreas a serem removidas. Se nenhuma máscara explícita for fornecida, o serviço usará o canal alfa da imagem de entrada. A máscara terá precedência se ambos forem fornecidos.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de apagamento.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Remover plano de fundo
Remover plano de fundo permite isolar os objetos do fundo com precisão.
Remover plano de fundo tem os seguintes parâmetros obrigatórios:
+ **image**: (string) a imagem em base64 da qual o plano de fundo deve ser removido. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de remoção de plano de fundo.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Controle
A seção a seguir descreve o controle do Stability AI Image Services.
### Controlar esboço
Aprimore esboços grosseiros desenhados à mão para obter saídas refinadas com controle preciso. Para imagens sem esboço, controlar esboço permite a manipulação detalhada da aparência final, aproveitando as linhas de contorno e as bordas da imagem.
Controlar esboço tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **control\$1strength**: (número) grau de influência ou controle que a imagem tem na geração. Representado como uma número flutuante entre 0 e 1, em que 0 é a influência mínima e 1 é a máxima. Padrão: 0,7.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada de controle de esboço usando o seguinte prompt: *a house with background of mountains and river flowing nearby*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Controlar estrutura
Controlar estrutura permite gerar imagens enquanto mantém a estrutura de uma imagem de entrada. Isso é especialmente valioso para cenários avançados de criação de conteúdo, como recriar cenas ou renderizar personagens com base em modelos.
Controlar estrutura tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **control\$1strength**: (número) grau de influência ou controle que a imagem tem na geração. Representado como uma número flutuante entre 0 e 1, em que 0 é a influência mínima e 1 é a máxima. Padrão: 0,7.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de controle de estrutura usando o seguinte prompt: *surreal structure with motion generated sparks lighting the scene*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Guia de estilo
O guia de estilo permite que você extraia elementos estilísticos de uma imagem de entrada e os utilize para orientar a criação de uma imagem de saída com base no prompt. O resultado é uma nova imagem no mesmo estilo da imagem de entrada.
Guia de estilo tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Padrão 1:1.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **fidelity**: (número) Até que ponto o estilo da imagem de saída se assemelha ao estilo da imagem de entrada. Varia de 0 a 1. Padrão: 0,5.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art e tile-texture.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada do guia de estilo usando o seguinte prompt: *wide shot of modern metropolis*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Transferência de estilo
A transferência de estilo permite que você aplique características visuais de imagens de estilo de referência às imagens de destino. Enquanto o serviço guia de estilo extrai elementos estilísticos de uma imagem de entrada e os utiliza para orientar a criação de uma imagem de saída com base no prompt, a transferência de estilo transforma especificamente o conteúdo existente e, ao mesmo tempo, preserva a composição original. Essa ferramenta ajuda a criar conteúdo consistente em vários ativos.
A transferência de estilo tem os seguintes parâmetros obrigatórios:
+ **init\$1image**: (string) uma imagem em base64 contendo o assunto que você deseja estilizar novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **style\$1image**: (string) uma imagem em base64 contendo o assunto que você deseja estilizar novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **composition\$1fidelity**: (número) até que ponto o estilo da imagem de saída se assemelha ao estilo da imagem de entrada. Varia de 0 a 1. Padrão: 0,9.
+ **style\$1strength**: (número) às vezes chamado de redução de ruído, esse parâmetro controla quanta influência o parâmetro da imagem tem sobre a imagem gerada. Um valor de 0 produziria uma imagem idêntica à entrada. Um valor de 1 seria como se você não tivesse passado nenhuma imagem. Varia de 0 a 1. Padrão: 1.
+ **change\$1strength**: (número) quanto a imagem original deve mudar. Varia de 0,1 a 1. Padrão: 0,9.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
style_image = "./content/style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/cat_statue_512x512.jpg"
style_image = "./content/glowbot_style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada de transferência de estilo.
| Input | Estilo | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |
# Modelos da TwelveLabs
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da TwelveLabs. Use essas informações para fazer chamadas de inferência para modelos da TwelveLabs. O TwelveLabs Pegasus 1.2 modelo suporta [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operações [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(de streaming). Os TwelveLabs Marengo Embed 3.0 modelos TwelveLabs Marengo Embed 2.7 e suportam [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)as operações. Esta seção também inclui exemplos de código que mostram como chamar modelos da TwelveLabs. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
A TwelveLabs é uma fornecedora líder de modelos de IA multimodais especializada em compreensão e análise de vídeo. Seus modelos avançados permitem recursos sofisticados de pesquisa, análise e geração de conteúdo de vídeo por meio de tecnologias de visão state-of-the-art computacional e processamento de linguagem natural.
O Amazon Bedrock oferece três TwelveLabs modelos:
+ TwelveLabs Pegasus 1.2fornece compreensão e análise abrangentes de vídeo.
+ TwelveLabs Marengo Embed 2.7gera incorporações de alta qualidade para conteúdo de vídeo, texto, áudio e imagem.
+ TwelveLabs Marengo Embed 3.0é o modelo de incorporação mais recente com desempenho e recursos aprimorados.
Esses modelos ajudam você a criar aplicativos que processam, analisam e obtêm insights de dados de vídeo em grande escala.
**TwelveLabs Pegasus 1.2**
Um modelo multimodal que fornece recursos abrangentes de compreensão e análise de vídeo, como reconhecimento de conteúdo, detecção de cenas e compreensão contextual. O modelo pode analisar conteúdo de vídeo e gerar descrições textuais, insights e respostas a perguntas feitas ao vídeo.
**TwelveLabs Marengo Embed 2.7**
Um modelo de incorporação multimodal que gera representações vetoriais de alta qualidade de conteúdo de vídeo, texto, áudio e imagem para pesquisa por similaridade, agrupamento e outras tarefas de machine learning. O modelo aceita várias modalidades de entrada e oferece incorporações especializadas otimizadas para diferentes casos de uso.
**TwelveLabs Marengo Embed 3.0**
Um modelo de incorporação multimodal aprimorado que amplia os recursos do Marengo 2.7 com suporte para a modalidade de entrada intercalada de texto e imagem. Esse modelo gera representações vetoriais de alta qualidade de vídeo, texto, áudio, imagem e conteúdo de texto-imagem intercalado para pesquisa por similaridade, agrupamento e outras tarefas de aprendizado de máquina.
**Topics**
+ [TwelveLabs Pegasus 1.2](model-parameters-pegasus.md)
+ [TwelveLabs Marengo Embed 2.7](model-parameters-marengo.md)
+ [TwelveLabs Marengo Embed 3.0](model-parameters-marengo-3.md)
# TwelveLabs Pegasus 1.2
O modelo TwelveLabs Pegasus 1.2 oferece recursos abrangentes de compreensão e análise de vídeo. Ele pode analisar conteúdo de vídeo e gerar descrições textuais, insights e respostas a perguntas feitas ao vídeo.
Use essas informações para fazer chamadas de inferência para TwelveLabs modelos com as operações InvokeModel, InvokeModelWithResponseStream (streaming).
+ Fornecedor — TwelveLabs
+ Categorias: compreensão e análise de conteúdo de vídeo
+ ID de modelo: `twelvelabs.pegasus-1-2-v1:0`
+ Modalidade de entrada: vídeo
+ Modalidade de saída: texto
+ Duração máxima do vídeo: vídeo de 1 hora (tamanho de arquivo < 2 GB)
## Parâmetros de solicitação do TwelveLabs Pegasus 1.2
A seguinte tabela descreve os parâmetros de entrada para o modelo TwelveLabs Pegasus 1.2.
**Parâmetros de solicitação do TwelveLabs Pegasus 1.2**
| Campo | Tipo | Obrigatório | Descrição |
| --- | --- | --- | --- |
| inputPrompt | string | Sim | Prompt para analisar o vídeo. Máximo: 2 mil tokens. |
| temperature | double | Não | Temperatura do modelo. Controla a randomização na saída. Padrão: 0,2; Mín.: 0; Máx.: 1. |
| responseFormat | Objeto | Não | Permite que os usuários especifiquem o formato de saída estruturado. No momento, aceita somente json\$1schema. |
| mediaSource | objeto | Sim | Descreve a fonte de mídia. É necessário fornecer base64String ou s3Location. |
| mediaSource.base64String | string | Não | String de bytes codificada em base64 para o vídeo. Máximo: 25MB. |
| mediaSource.s3Location.uri | string | Não | URI do S3 no qual o vídeo pode ser baixado. Máx.: vídeo de 1 hora (tamanho de arquivo < 2 GB). |
| mediaSource.s3Location.bucketOwner | string | Não | O ID da conta da AWS do proprietário do bucket. |
| maxOutputTokens | integer | Não | O número máximo de tokens a serem gerados. Máx: 4.096. |
## Campos de resposta TwelveLabs Pegasus 1.2
A tabela a seguir descreve os campos para o modelo TwelveLabs Pegasus 1.2.
**Campos de resposta TwelveLabs Pegasus 1.2**
| Campo | Tipo | Description |
| --- | --- | --- |
| message | string | Mensagem de saída contendo a análise do vídeo pelo modelo. |
| finishReason | string | Motivo da interrupção que descreve por que a saída foi encerrada. Valores válidos: stop (a API exibiu os preenchimentos completos sem atingir nenhum limite), length (a geração ultrapassou o limite de max\$1tokens). |
## Solicitação e reposta do TwelveLabs Pegasus 1.2
Os exemplos a seguir mostram como usar o modelo TwelveLabs Pegasus 1.2 com diferentes fontes de entrada.
------
#### [ Request ]
Os exemplos a seguir mostram os formatos de solicitação para o modelo TwelveLabs Pegasus 1.2.
**Usar vídeo codificado em base64:**
```
{
"inputPrompt": "tell me about the video",
"mediaSource": {
"base64String": ""
},
"temperature": 0
}
```
**Usar vídeo armazenado no S3:**
```
{
"inputPrompt": "Tell me about this video",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0
}
```
**Usar o formato de saída estruturada:**
```
{
"inputPrompt": "Analyze this video and provide a structured summary",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0.2,
"maxOutputTokens": 2048,
"responseFormat": {
"type": "json_schema",
"json_schema": {
"name": "video_analysis",
"schema": {
"type": "object",
"properties": {
"summary": {"type": "string"},
"key_scenes": {"type": "array", "items": {"type": "string"}},
"duration": {"type": "string"}
},
"required": ["summary", "key_scenes"]
}
}
}
}
```
------
#### [ Response ]
Os exemplos a seguir mostram os formatos de resposta do modelo TwelveLabs Pegasus 1.2.
**Resposta padrão:**
```
{
"message": "This video shows a person walking through a park during sunset. The scene includes trees, a walking path, and golden lighting from the setting sun. The person appears to be enjoying a peaceful evening stroll.",
"finishReason": "stop"
}
```
**Resposta com saída estruturada:**
```
{
"message": "{\"summary\": \"A peaceful evening walk through a park at sunset\", \"key_scenes\": [\"Person entering the park\", \"Walking along tree-lined path\", \"Sunset lighting through trees\", \"Person sitting on bench\"], \"duration\": \"Approximately 2 minutes\"}",
"finishReason": "stop"
}
```
**Resposta quando o máximo de tokens foi atingido:**
```
{
"message": "This video contains multiple scenes showing various activities. The first scene shows...",
"finishReason": "length"
}
```
------
# TwelveLabs Marengo Embed 2.7
O modelo TwelveLabs Marengo Embed 2.7 gera incorporações com base em entradas de vídeo, texto, áudio ou imagem. Essas incorporações podem ser usadas para pesquisa por similaridade, agrupamento e outras tarefas de machine learning.
+ Fornecedor — TwelveLabs
+ ID de modelo: twelvelabs.marengo-embed-2-7-v1:0
O modelo TwelveLabs Marengo Embed 2.7 permite as operações do Amazon Bedrock Runtime descritas na tabela a seguir.
+ Para ter mais informações sobre casos de uso para diferentes métodos de API, consulte [Saiba mais sobre os casos de uso para diferentes métodos de inferência do modelo.Diferentes métodos de inferência](inference-methods.md).
+ Para ter mais informações sobre os tipos de modelo, consulte [Como a inferência funciona no Amazon BedrockComo a inferência funciona](inference-how.md).
+ Para obter uma lista de modelos IDs e ver os modelos e AWS regiões compatíveis com, pesquise o modelo na tabela em[Modelos de base compatíveis no Amazon Bedrock](models-supported.md). TwelveLabs Marengo Embed 2.7
+ Para obter uma lista completa do perfil de inferência IDs, consulte[Regiões e modelos que compatíveis com perfis de inferência](inference-profiles-support.md). O ID do perfil de inferência é baseado na AWS região.
****
| Operação de API | Tipos de modelo compatíveis | Modalidades de entrada | Modalidades de saída |
| --- | --- | --- | --- |
| InvokeModel | [Perfis de inferência](inference-profiles-support.md) | Texto Imagem | Incorporação |
| StartAsyncInvoke | [Modelos básicos](models-supported.md) | Vídeo Áudio Imagem Texto | Incorporação |
**nota**
Use `InvokeModel` para gerar incorporações para consulta de pesquisa. Use `StartAsyncInvoke` para gerar incorporações para ativos em grande escala.
As seguintes cotas se aplicam à saída:
****
| Modalidade de entrada | Máximo |
| --- | --- |
| Texto | 77 tokens |
| Imagem | 5 MB |
| Vídeo (S3) | 2 GB |
| Áudio (S3) | 2 GB |
**nota**
Se você definir áudio ou vídeo em linha usando a codificação em base64, a carga útil do corpo da solicitação não deve ultrapassar a cota de invocação de 25 MB do modelo do Amazon Bedrock.
**Topics**
+ [Parâmetros de solicitação do TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-async-request)
+ [Resposta TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-response)
+ [Exemplos de código do TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-examples)
## Parâmetros de solicitação do TwelveLabs Marengo Embed 2.7
Quando você faz uma solicitação, o campo no qual a entrada específica do modelo é estipulada depende da operação de API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Na solicitação`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— No `modelInput` campo do corpo da solicitação.
O formato da entrada do modelo depende da modalidade de entrada:
------
#### [ Text ]
```
{
"inputType": "text",
"inputText": "string",
"textTruncate": "string
}
```
------
#### [ Inline image ]
```
{
"inputType": "image",
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
------
#### [ S3 image ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
}
```
------
#### [ Inline video ]
```
{
"inputType": "video",
"mediaSource": {
"s3Location": {
"base64String": "base64-encoded string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"embeddingOption": "visual-text" | "visual-image" | "audio"
}
```
------
#### [ S3 video ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"minClipSec": int,
"embeddingOption": ["string"]
}
```
------
#### [ Inline audio ]
```
{
"inputType": "audio",
"mediaSource": {
"base64String": "base64-encoded string"
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
#### [ S3 audio ]
```
{
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
Expanda as seguintes seções para obter detalhes sobre os parâmetros de entrada:
### inputType
Modalidade para a incorporação.
+ **Tipo:** string
+ **Obrigatório**: Sim
+ **Valores válidos**: `video` \$1 `text` \$1 `audio` \$1 `image`
### inputText
Texto a ser incorporado.
+ **Tipo:** string
+ **Obrigatório:** sim (para tipos de entrada compatíveis)
+ **Tipos de entrada compatíveis:** texto
### textTruncate
Especifica como a plataforma trunca o texto.
+ **Tipo:** string
+ **Obrigatório**: não
+ **Valores válidos:**
+ `end`: trunca o final do texto.
+ `none`: exibe um erro se o texto exceder o limite.
+ **Valor padrão:** end
+ **Tipos de entrada compatíveis:** texto
### mediaSource
Contém informações sobre a fonte de mídia.
+ **Tipo:** objeto
+ **Obrigatório:** sim (se for do tipo compatível)
+ **Tipos de entrada compatíveis:** imagem, vídeo, áudio
O formato do objeto `mediaSource` no corpo da solicitação depende se a mídia está definida como uma string codificada em base64 ou como um local do S3.
+ **Cadeia de caracteres codificada em Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: a string codificada em base64 para a mídia.
+ **Localização do S3** — especifique o URI do S3 e o proprietário do bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: o URI do S3 que contém a mídia.
+ `bucketOwner`— O ID da AWS conta do proprietário do bucket S3.
### embeddingOption
Especifica quais tipos de incorporação devem ser recuperadas.
+ **Tipo**: lista
+ **Obrigatório**: não
+ **Valores válidos para membros da lista:**
+ `visual-text`: incorporações visuais otimizadas para pesquisa de texto.
+ `visual-image`: incorporações visuais otimizadas para pesquisa de imagens.
+ `audio`: incorporações de áudio no vídeo.
+ **Valor padrão:** [“visual-text”, “visual-image”, “audio”]
+ **Tipos de entrada compatíveis:** vídeo, áudio
### startSec
O ponto no tempo em segundos do clipe em que o processamento deve começar.
+ **Tipo**: duplo
+ **Obrigatório**: não
+ **Valor mínimo**: 0
+ **Valor padrão:** 0
+ **Tipos de entrada compatíveis:** vídeo, áudio
### lengthSec
O tempo em segundos, contado a partir do ponto `startSec`, após o qual o processamento deve ser interrompido.
+ **Tipo**: duplo
+ **Obrigatório**: não
+ **Valores válidos:** 0 (duração da mídia).
+ **Valor padrão:** duração da mídia.
+ **Tipos de entrada compatíveis:** vídeo, áudio
Exemplo:
+ startSec: 5
+ lengthSec: 20
+ Resultado: O clipe é processado de 0:05 a 0:25 (5 segundos \$1 20 segundos).
### useFixedLengthSec
A duração de cada clipe para o qual o modelo deve gerar uma incorporação.
+ **Tipo**: duplo
+ **Obrigatório**: não
+ **Parâmetros de valor:** 2-10. Deve ser maior que ou igual a `minClipSec`.
+ **Valor padrão:** depende do tipo de mídia:
+ **Vídeo:** Dividido dinamicamente pela detecção do limite de disparo.
+ **Áudio:** dividido uniformemente com segmentos o mais próximo possível de 10 segundos.
Exemplos:
+ Um clipe de 50 segundos é dividido em 5 segmentos de 10 segundos.
+ Um clipe de 16 segundos é dividido em 2 segmentos de 8 segundos.
+ **Tipos de entrada compatíveis:**: vídeo, áudio
+ **Observações**: deve ser maior que ou igual a `minClipSec`.
### minClipSec
Define um valor mínimo para cada clipe em segundos.
+ Tipo: inteiro
+ **Obrigatório**: não
+ **Parâmetros de valor:** intervalo: 1-5
+ **Valor padrão:** 4
+ **Tipos de entrada compatíveis:** vídeo
+ **Observações**: deve ser menor que ou igual a `useFixedLengthSec`.
## Resposta TwelveLabs Marengo Embed 2.7
A localização das incorporações de saída e dos metadados associados depende do método de invocação:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— No corpo da resposta.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— No bucket do S3 definido no`s3OutputDataConfig`, após a conclusão do trabalho de invocação assíncrona.
Se houver vários vetores de incorporação, a saída será uma lista de objetos, cada um contendo um vetor e os metadados correspondentes.
O formato do vetor de incorporações de saída é o seguinte:
```
{
"embedding": ["string"],
"embeddingOption": "visual-text" | "visual-image" | "audio",
"startSec": double,
"endsec": double
}
```
Expanda as seguintes seções para obter detalhes sobre os parâmetros de resposta:
### incorporação
Representação vetorial de incorporações da entrada.
+ **Tipo**: lista de duplos
### embeddingOption
O tipo de incorporação.
+ **Tipo:** string
+ **Valores possíveis:**
+ `visual-text`: incorporações visuais otimizadas para pesquisa de texto.
+ `visual-image`: incorporações visuais otimizadas para pesquisa de imagens.
+ `audio`: incorporações de áudio no vídeo.
+ **Tipos de entrada compatíveis:** vídeo
### startSec
O deslocamento inicial do clipe.
+ **Tipo**: duplo
+ **Tipos de entrada compatíveis:** vídeo, áudio
### endSec
O deslocamento final do clipe, em segundos.
+ **Tipo**: duplo
+ **Tipos de entrada compatíveis:** vídeo, áudio
## Exemplos de código do TwelveLabs Marengo Embed 2.7
Esta seção mostra como usar o modelo TwelveLabs Marengo Embed 2.7 com diferentes tipos de entrada usando Python. Os exemplos demonstram como definir a entrada específica do modelo e executar invocações do modelo.
**nota**
InvokeModel suporta somente entrada de texto e imagem. Para entrada de vídeo e áudio, use StartAsyncInvoke.
Organize seu código nas seguintes etapas:
**1. Defina a entrada específica do modelo**
Defina a entrada específica do modelo dependendo do tipo de entrada:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "text",
"inputText": "man walking a dog"
}
```
------
#### [ Inline image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"base64String": "example-base64-image"
}
}
```
------
#### [ S3 image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
```
------
#### [ Inline video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"base64String": "base_64_encoded_string_of_video"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ S3 video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"s3Location": {
"uri": "amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ Inline audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"base64String": "base_64_encoded_string_of_audio"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
#### [ S3 audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
**2. Execute a invocação do modelo usando a entrada do modelo**
Em seguida, adicione o trecho de código que corresponde ao método de invocação do modelo de sua preferência.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://&example-s3-destination-bucket;"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# TwelveLabs Marengo Embed 3.0
O TwelveLabs Marengo Embed 3.0 modelo gera incorporações aprimoradas a partir de entradas de vídeo, texto, áudio ou imagem. Essa versão mais recente oferece desempenho e precisão aprimorados para pesquisa por similaridade, agrupamento e outras tarefas de aprendizado de máquina.
+ Fornecedor — TwelveLabs
+ ID de modelo: twelvelabs.marengo-embed-3-0-v1:0
O Marengo Embed 3.0 oferece vários aprimoramentos importantes:
+ **Capacidade de processamento de vídeo estendida** — Processe até 4 horas de conteúdo de vídeo e áudio. Os arquivos podem ter até 6 GB, o dobro da capacidade das versões anteriores. Isso o torna ideal para analisar eventos esportivos completos, vídeos de treinamento estendidos e produções cinematográficas completas.
+ **Análise esportiva aprimorada** — O modelo oferece melhorias significativas. Ele fornece uma melhor compreensão da dinâmica do jogo, dos movimentos do jogador e da detecção de eventos.
+ **Suporte multilíngue global** — Capacidades linguísticas expandidas de 12 para 36 idiomas. Isso permite que organizações globais criem sistemas unificados de busca e recuperação que funcionem perfeitamente em diversas regiões e mercados.
+ **Precisão de pesquisa multimodal** — combine imagens e texto descritivo em uma única solicitação de incorporação. Isso combina semelhança visual com compreensão semântica para fornecer resultados de pesquisa mais precisos e contextualmente relevantes.
+ **Dimensão de incorporação reduzida** — Reduzida de 1024 para 512, o que pode ajudar a reduzir os custos de armazenamento.
O modelo TwelveLabs Marengo Embed 3.0 permite as operações do Amazon Bedrock Runtime descritas na tabela a seguir.
+ Para ter mais informações sobre casos de uso para diferentes métodos de API, consulte [Saiba mais sobre os casos de uso para diferentes métodos de inferência do modelo.Diferentes métodos de inferência](inference-methods.md).
+ Para ter mais informações sobre os tipos de modelo, consulte [Como a inferência funciona no Amazon BedrockComo a inferência funciona](inference-how.md).
+ Para obter uma lista de modelos IDs e ver os modelos e AWS regiões compatíveis com, pesquise o modelo na tabela em[Modelos de base compatíveis no Amazon Bedrock](models-supported.md). TwelveLabs Marengo Embed 3.0
+ Para obter uma lista completa do perfil de inferência IDs, consulte[Regiões e modelos que compatíveis com perfis de inferência](inference-profiles-support.md). O ID do perfil de inferência é baseado na AWS região.
****
| Operação de API | Tipos de modelo compatíveis | Modalidades de entrada | Modalidades de saída |
| --- | --- | --- | --- |
| InvokeModel | Leste dos EUA (Norte da Virgínia) — [Modelos básicos](models-supported.md) e perfis de [inferência](inference-profiles-support.md) Europa (Irlanda) [— Perfis de inferência](inference-profiles-support.md) Ásia-Pacífico (Seul) - Modelos [básicos](models-supported.md) | Texto Imagem **Observação:** texto e imagem intercalados também são suportados. | Incorporação |
| StartAsyncInvoke | [Modelos básicos](models-supported.md) | Vídeo Áudio Imagem Texto **Observação:** texto e imagem intercalados também são suportados. | Incorporação |
**nota**
Use `InvokeModel` para gerar incorporações para consulta de pesquisa. Use `StartAsyncInvoke` para gerar incorporações para ativos em grande escala.
As seguintes cotas se aplicam à saída:
****
| Modalidade de entrada | Máximo |
| --- | --- |
| Texto | 500 fichas |
| Imagem | 5 MB por imagem |
| Vídeo (S3) | 6 GB, 4 horas de duração |
| Áudio (S3) | 6 GB, 4 horas de duração |
**nota**
Se você definir áudio ou vídeo em linha usando a codificação em base64, a carga útil do corpo da solicitação não deve ultrapassar a cota de invocação de 25 MB do modelo do Amazon Bedrock.
**Topics**
+ [Parâmetros de solicitação do TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-async-request)
+ [Resposta TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-response)
+ [Exemplos de código do TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-examples)
## Parâmetros de solicitação do TwelveLabs Marengo Embed 3.0
Quando você faz uma solicitação, o campo no qual a entrada específica do modelo é estipulada depende da operação de API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Na solicitação`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— No `modelInput` campo do corpo da solicitação.
O formato da entrada do modelo depende da modalidade de entrada:
------
#### [ Text ]
```
{
"inputType": "text",
"text": {
"inputText": "string"
}
}
```
------
#### [ Image ]
```
{
"inputType": "image",
"image": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
{
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
{
"inputType": "audio",
"audio": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/audio/a.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"audio",
"transcription"
], // optional, default=both
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
}
}
```
------
#### [ Video ]
```
{
"inputType": "video",
"video": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video/clip.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "dynamic", // dynamic OR fixed, exactly one
"dynamic": {
"minDurationSec": 4
}
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"visual",
"audio",
"transcription"
], // optional, default=all
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
},
"inferenceId": "some inference id"
}
```
------
Expanda as seguintes seções para obter detalhes sobre os parâmetros de entrada:
### inputType
Modalidade para a incorporação.
+ **Tipo:** string
+ **Obrigatório**: Sim
+ **Valores válidos**: `text` \$1 `image` \$1 `text_image` \$1 `audio` \$1 `video`
### inputText
Texto a ser incorporado.
+ **Tipo:** string
+ **Obrigatório:** sim (para tipos de entrada compatíveis)
+ **Tipos de entrada compatíveis:** texto
### mediaSource
Contém informações sobre a fonte de mídia.
+ **Tipo:** objeto
+ **Obrigatório:** sim (se for do tipo compatível)
+ **Tipos de entrada compatíveis:** imagem, vídeo, áudio
O formato do objeto `mediaSource` no corpo da solicitação depende se a mídia está definida como uma string codificada em base64 ou como um local do S3.
+ **Cadeia de caracteres codificada em Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String`: a string codificada em base64 para a mídia.
+ **Localização do S3** — especifique o URI do S3 e o proprietário do bucket.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri`: o URI do S3 que contém a mídia.
+ `bucketOwner`— O ID da AWS conta do proprietário do bucket do S3.
### embeddingOption
Especifica quais tipos de incorporação devem ser recuperadas.
+ **Tipo**: lista
+ **Obrigatório**: não
+ **Valores válidos para membros da lista:**
+ `visual`— Incorporações visuais do vídeo.
+ `audio`: incorporações de áudio no vídeo.
+ `transcription`— Incorporações do texto transcrito.
+ **Valor padrão:**
+ Vídeo: ["visual”, “áudio”, “transcrição"]
+ Áudio: ["áudio”, “transcrição"]
+ **Tipos de entrada compatíveis:** vídeo, áudio
### Escopo de incorporação
Especifica o escopo das incorporações a serem recuperadas.
+ **Tipo**: lista
+ **Obrigatório**: não
+ **Valores válidos para membros da lista:**
+ `clip`— Retorna as incorporações de cada clipe.
+ `asset`— Retorna incorporações para todo o ativo.
+ **Tipos de entrada compatíveis:** vídeo, áudio
### startSec
O ponto no tempo em segundos do clipe em que o processamento deve começar.
+ **Tipo**: duplo
+ **Obrigatório**: não
+ **Valor mínimo**: 0
+ **Valor padrão:** 0
+ **Tipos de entrada compatíveis:** vídeo, áudio
### endSec
O momento em segundos em que o processamento deve terminar.
+ **Tipo**: duplo
+ **Obrigatório**: não
+ **Valor mínimo:** StartSec \$1 comprimento do segmento
+ **Valor máximo:** duração da mídia
+ **Valor padrão:** duração da mídia.
+ **Tipos de entrada compatíveis:** vídeo, áudio
### segmentation
Define como a mídia é dividida em segmentos para geração de incorporação.
+ **Tipo:** objeto
+ **Obrigatório**: não
+ **Tipos de entrada compatíveis:** vídeo, áudio
O objeto de segmentação contém um `method` campo e parâmetros específicos do método:
+ `method`— O método de segmentação a ser usado. Valores válidos: `dynamic` \$1 `fixed`
+ `dynamic`— Para vídeo, usa a detecção de limites de captura para dividir o conteúdo dinamicamente. Contém:
+ `minDurationSec`— Duração mínima para cada segmento em segundos. Tipo: número inteiro. Intervalo: 1-5. Padrão: 4.
+ `fixed`— Divide o conteúdo em segmentos de igual duração. Contém:
+ `durationSec`— Duração de cada segmento em segundos. Tipo: número inteiro. Intervalo: 1-10. Padrão: 6.
**Comportamento padrão**:
+ Vídeo: usa segmentação dinâmica com detecção de limites de disparo.
+ Áudio: usa segmentação fixa. O conteúdo é dividido o mais uniformemente possível com segmentos próximos a 10 segundos.
### ID de inferência
Identificador exclusivo para a solicitação de inferência.
+ **Tipo:** string
+ **Obrigatório**: não
## Resposta TwelveLabs Marengo Embed 3.0
A localização das incorporações de saída e dos metadados associados depende do método de invocação:
+ InvokeModel — No corpo da resposta.
+ StartAsyncInvoke — No bucket S3 definido em`s3OutputDataConfig`, após a conclusão do trabalho de invocação assíncrona.
Se houver vários vetores de incorporação, a saída será uma lista de objetos, cada um contendo um vetor e os metadados correspondentes.
O formato do vetor de incorporações de saída é o seguinte:
```
{
"data": {
"embedding": [
0.111, 0.234, ...
],
"embeddingOption": ["visual", "audio", "transcription" (for video input) | "audio", "transcription" (for audio input)],
"embeddingScope": ["asset" | "clip"],
"startSec": 0,
"endSec": 4.2
}
}
```
As incorporações são retornadas como uma matriz de flutuadores.
O local em que você vê essa resposta depende do método de API usado:
+ InvokeModel — Aparece no corpo da resposta.
+ StartAsyncInvoke — Aparece no local do S3 que você especificou na solicitação. A resposta retorna um`invocationArn`. Você pode usar isso para obter metadados sobre a invocação assíncrona. Isso inclui o status e a localização do S3 em que os resultados são gravados.
Expanda as seguintes seções para obter detalhes sobre os parâmetros de resposta:
### incorporação
Representação vetorial de incorporações da entrada.
+ **Tipo**: lista de duplos
### embeddingOption
O tipo de incorporação.
+ **Tipo:** string
+ **Valores possíveis:**
+ visual — Incorporações visuais do vídeo.
+ áudio — Incorporações do áudio no vídeo.
+ transcrição — Incorporações do texto transcrito.
+ **Tipos de entrada compatíveis:** vídeo, áudio
### Escopo de incorporação
Especifica o escopo das incorporações a serem recuperadas.
+ **Tipo:** string
Você pode incluir um ou mais dos seguintes valores:
+ clipe: retorna as incorporações de cada clipe.
+ ativo: retorna incorporações para todo o ativo.
### startSec
O deslocamento inicial do clipe.
+ **Tipo**: duplo
+ **Tipos de entrada compatíveis:** vídeo, áudio
### endSec
O deslocamento final do clipe. Não aplicável para incorporações de texto, imagem e text\$1image.
+ **Tipo**: duplo
+ **Tipos de entrada compatíveis:** vídeo, áudio
## Exemplos de código do TwelveLabs Marengo Embed 3.0
Esta seção mostra como usar o modelo TwelveLabs Marengo Embed 3.0 com diferentes tipos de entrada usando Python. Os exemplos demonstram como definir a entrada específica do modelo e executar invocações do modelo.
**nota**
InvokeModel suporta texto, imagem e texto com entrada intercalada de imagem. Para entrada de vídeo e áudio, use StartAsyncInvoke.
Organize seu código nas seguintes etapas:
**1. Defina a entrada específica do modelo**
Defina a entrada específica do modelo dependendo do tipo de entrada:
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text",
"text": {
"inputText": "man walking a dog"
}
}
```
------
#### [ Image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "image",
"image": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "audio",
"audio": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 5,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingScope": ["clip", "asset"],
"embeddingOption": ["audio"]
}
}
```
------
#### [ Video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "video",
"video": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 10,
"endSec": 20,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingOption": [
"visual",
"audio"
],
"embeddingScope": [
"clip",
"asset"
]
}
}
```
------
**2. Execute a invocação do modelo usando a entrada do modelo**
Em seguida, adicione o trecho de código que corresponde ao método de invocação do modelo de sua preferência.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://amzn-s3-demo-bucket"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# Modelos Palmyra da Writer AI
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Writer AI. Use essas informações para fazer chamadas de inferência a modelos da Writer AI com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da Writer AI. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da Writer AI específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da Writer AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da Writer AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS esses modelos da Writer AI estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da Writer AI, inclua um prompt no modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para obter informações de prompts específicos da Writer AI, consulte o [Writer AI prompt engineering guide]().
**Writer Palmyra X4**
Com a melhor classificação no Stanford HELM, o Writer Palmyra X4 alcança desempenho superior em tarefas complexas e fluxos de trabalho agênticos. Ele oferece uma janela de contexto de 128 mil tokens e um conjunto de recursos de empresarial, como raciocínio avançado, chamada de ferramentas, delegação de LLM, RAG integrada, geração de código, saídas estruturadas, multimodalidade e suporte multilíngue. Usando ferramentas específicas da empresa que ampliam a capacidade de ação do modelo, o Palmyra X4 permite que os desenvolvedores criem aplicações e agentes que atualizam o sistema, realizam transações, enviam e-mails, acionam o fluxo de trabalho etc.
**Writer Palmyra X5**
Com uma janela de contexto de 1 milhão de tokens, o Writer Palmyra X5 é um marco do fim das restrições de contexto para o desenvolvimento de aplicações e agentes. O modelo mais novo da Writer alcança desempenho superior em inferência de contexto longo por meio de memória expandida e poder de processamento, permitindo que os desenvolvedores criem fluxos de trabalho agênticos mais complexos e de várias etapas mais depressa. Tal como o Palmyra X4, o Palmyra X5 inclui um conjunto de recursos prontos para uso empresarial, como raciocínio avançado, chamada de ferramentas, delegação de LLM, RAG integrada, geração de código, saídas estruturadas, multimodalidade e suporte multilíngue.
**Topics**
+ [Writer Palmyra X4](model-parameters-palmyra-x4.md)
+ [Writer Palmyra X5](model-parameters-palmyra-x5.md)
# Writer Palmyra X4
O Writer Palmyra X4 é um modelo com uma janela de contexto de até 128 mil tokens. Esse modelo é excelente para processamento e compreensão de tarefas complexas, o que o torna ideal para automação de fluxos de trabalho, tarefas de codificação e análise de dados.
+ Fornecedor: Writer
+ Categorias: geração de texto, geração de código, formatação de rich text
+ Última versão: v1
+ Data de lançamento: 28 de abril de 2025
+ ID de modelo: `writer.palmyra-x4-v1:0`
+ Modalidade: texto
+ Máximo de tokens: entrada: 122.880 tokens, saída: 8.192 tokens
+ Idioma: inglês, espanhol, francês, alemão, chinês e vários outros
+ Tipo de implantação: sem servidor
## Campo do corpo da resposta de invocação do Palmyra X4
Ao fazer uma chamada [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) usando um modelo da Writer, preencha o campo `body` com um objeto JSON que esteja em conformidade com o modelo abaixo. Insira o prompt no campo `text` do objeto `text_prompts`.
```
{
"modelId": "writer.palmyra-x4-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
A tabela a seguir mostra os valores mínimo, máximo e padrão para os parâmetros numéricos.
****
| Parameter | Tipo | Padrão | Intervalo/Validação | Descrição |
| --- | --- | --- | --- | --- |
| mensagens | array | Obrigatório | 1-∞ itens | Mensagens do histórico de chat |
| temperature | flutuação | 1,0 | 0.0 ≤ x ≤ 2.0 | Temperatura da amostragem |
| top\$1p | flutuação | 1,0 | 0.0 < value ≤ 1.0 | Limite da amostragem do núcleo |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8192 | Máximo de tokens a serem gerados |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Tokens mínimos antes de parar |
| parar | array | [] | ≤4 entradas | Sequências de paradas |
| semente | int | nulo | Qualquer inteiro | Random seed (Semente aleatória) |
| presence\$1penalty | flutuação | 0.0 | -2.0 ≤ x ≤ 2.0 | Penalidade de presença de um novo token |
| frequency\$1penalty | flutuação | 0.0 | -2.0 ≤ x ≤ 2.0 | Penalidade de frequência de token |
## Campo do corpo da resposta de invocação do Palmyra X4
A resposta JSON para o Writer Palmyra X4 usa o seguinte formato:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x4-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```
## Writer Palmyra X4Código de exemplo do
Exemplo de código para o Writer Palmyra X4:
```
import boto3
import json
from botocore.exceptions import ClientError
client = boto3.client("bedrock-runtime", region_name="us-west-2")
model_id = "writer.palmyra-x4-v1:0"
# Format the request payload using the model's native structure.
native_request = {
"temperature": 1,
"messages": [
{
"role": "user",
"content": "Explain quantum computing in simple terms.",
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["content"][0]["text"]
print(response_text)
```
# Writer Palmyra X5
O Writer Palmyra X5 inclui um conjunto de recursos prontos para uso corporativo, como raciocínio avançado, chamada de ferramentas, delegação de LLM, RAG integrada, geração de código, saídas estruturadas, multimodalidade e suporte multilíngue.
O modelo Writer Palmyra X5 tem os seguintes controles:
+ Fornecedor: Writer
+ Categorias: geração de texto, geração de código, formatação de rich text
+ Última versão: v1
+ Data de lançamento: 28 de abril de 2025
+ ID de modelo: `writer.palmyra-x5-v1:0`
+ Modalidade: texto
+ Máximo de tokens: entrada de 1.040.000 tokens e saída de 8.192 tokens
+ Idioma: inglês, espanhol, francês, alemão, chinês e vários outros
+ Tipo de implantação: sem servidor
## Campo do corpo da resposta de invocação do Palmyra X5
Ao fazer uma chamada [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) usando um modelo da Writer, preencha o campo `body` com um objeto JSON que esteja em conformidade com o modelo abaixo. Insira o prompt no campo `text` do objeto `text_prompts`.
```
{
"modelId": "writer.palmyra-x5-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
A tabela a seguir mostra os valores mínimo, máximo e padrão para os parâmetros numéricos.
****
| Parameter | Tipo | Padrão | Intervalo/Validação | Descrição |
| --- | --- | --- | --- | --- |
| mensagens | array | Obrigatório | 1-∞ itens | Mensagens do histórico de chat |
| temperature | flutuação | 1,0 | 0.0 ≤ x ≤ 2.0 | Temperatura da amostragem |
| top\$1p | flutuação | 1,0 | 0.0 < x ≤ 1.0 | Limite da amostragem do núcleo |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8192 | Máximo de tokens a serem gerados |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Tokens mínimos antes de parar |
| parar | array | [] | ≤4 entradas | Sequências de paradas |
| semente | int | nulo | Qualquer inteiro | Random seed (Semente aleatória) |
| presence\$1penalty | flutuação | 0.0 | -2.0 ≤ x ≤ 2.0 | Penalidade de presença de um novo token |
| frequency\$1penalty | flutuação | 0.0 | -2.0 ≤ x ≤ 2.0 | Penalidade de frequência de token |
## Campo do corpo da resposta de invocação do Palmyra X5
A resposta JSON para o Writer Palmyra X5 usa o seguinte formato:
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x5-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```