As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Modelos da DeepSeek
<a name="model-parameters-deepseek"></a>

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\_p**: (número flutuante) valor numérico menor ou igual a 1.
+ **max\_tokens** — (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\_reason**: (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｜><think>\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\_turn**: o modelo atingiu um ponto de parada natural.
  + **max\_tokens**: 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()
```