Modelos da OpenAI - Amazon Bedrock
OpenAIcorpo da solicitaçãoOpenAIcorpo de respostaExemplo de uso de OpenAI modelos

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 OpenAI

OpenAIoferece os seguintes modelos de peso aberto:

  • gpt-oss-20b— Um modelo menor otimizado para menor latência e casos de uso locais ou especializados.

  • gpt-oss-120b— Um modelo maior otimizado para casos de uso de produção e uso geral ou de alto raciocínio.

A tabela a seguir resume as 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 suportadas Texto Texto
Modalidades de saída suportadas Texto Texto
Janela de contexto 128.000 128.000

Os OpenAI modelos oferecem suporte aos seguintes recursos:

OpenAIcorpo da solicitação

Para obter informações sobre os parâmetros no corpo da solicitação e suas descrições, consulte Criar conclusão de bate-papo na OpenAI documentação.

Use os campos do corpo da solicitação das seguintes maneiras:

  • Em uma solicitação InvokeModelou de conclusão do OpenAI Chat, inclua os campos no corpo da solicitação.

  • Em uma solicitação Converse, faça o seguinte:

    • Mapeie o messages seguinte:

      • Para cada mensagem cuja função édeveloper, adicione content a SystemContentBlockna system matriz.

      • Para cada mensagem cuja função é user ouassistant, adicione content a a ContentBlockno content campo e especifique a role no role campo de uma Mensagem na messages matriz.

    • Mapeie os valores dos seguintes campos para os campos correspondentes no inferenceConfig objeto:

      OpenAI field Campo inverso
      tokens máximos de conclusão maxTokens
      parar stopSequences
      temperature temperatura
      top_p topP

    • Inclua qualquer outro campo no additionalModelRequestFields objeto.

Considerações ao construir o corpo da solicitação

  • Os OpenAI modelos suportam somente entrada e saída de texto.

  • O valor no model campo 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 stream campo 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, o stream valor deve serfalse.

OpenAIcorpo de resposta

O corpo da resposta dos OpenAI modelos está em conformidade com o objeto de conclusão do bate-papo retornado porOpenAI. Para obter mais informações sobre os campos de resposta, consulte O objeto de conclusão do chat na OpenAI documentação.

nota

Se você usarInvokeModel, o raciocínio do modelo, cercado por <reasoning> tags, precede o conteúdo do texto da resposta.

Exemplo de uso de OpenAI modelos

Esta seção fornece alguns exemplos de como usar os OpenAI modelos.

Antes de testar esses exemplos, verifique se você cumpriu os 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.

    nota

    Se você usar a API de conclusão do OpenAI Chat, 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. 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 suportada pelo modelo usado no exemplo.

  • Acesso ao modelo — Solicite acesso a um OpenAI modelo. Para obter mais informações, consulte Adicionar ou remover o acesso aos modelos de base do Amazon Bedrock.

  • (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 relevantes. Para obter mais informações sobre provedores de credenciais padronizados, consulte Ferramentas AWS SDKs e provedores de credenciais padronizados.

    nota

    Se você usar o OpenAI SDK, 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:

Para ver exemplos de uso da API OpenAI Create Chat Completion, escolha a guia do seu método preferido e siga as etapas:

OpenAI SDK (Python)

O script Python a seguir chama a API de conclusão de bate-papo Create com o SDK do PythonOpenAI:

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!"
        }
    ]
}'

Escolha a guia do seu método preferido 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'])

Ao usar a API unificada do Converse, você precisa mapear os campos de conclusão do OpenAI Create chat para o campo correspondente no corpo da solicitação do Converse.

Por exemplo, compare o corpo da solicitação de conclusão de bate-papo 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 do seu método preferido 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)

Aplique uma grade de proteção ao executar a invocação do modelo especificando o ID da grade de proteção, a versão e se deve ou não habilitar o rastreamento da grade de proteção no cabeçalho de uma solicitação de invocação do modelo.

Escolha a guia do seu método preferido 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

Para ver exemplos de uso de grades de proteção com a conclusão de OpenAI bate-papos, escolha a guia do seu método preferido 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<ChatCompletion> rawChatCompletionResponse =
        client.chat().completions().withRawResponse().create(request);

final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();

System.out.println(chatCompletion);

A inferência em lote permite que você execute a inferência de modelos de forma assíncrona com vários prompts. Para executar a inferência em lote com um OpenAI modelo, você faz 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 modelInput objeto deve estar em conformidade com o formato do corpo da solicitação de conclusão de OpenAI criação de bate-papo. Veja a seguir um exemplo das duas primeiras linhas de um arquivo JSONL contendo corpos de solicitação para. 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 model campo é 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á em conformidade com as cotas de inferência em lote, conforme descrito em. Formatar e carregar os dados de inferência

  2. Faça upload do arquivo para um bucket do Amazon S3.

  3. Envie uma CreateModelInvocationJobsolicitação com um endpoint do plano de controle Amazon Bedrock 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, consulteExemplo de código para inferência em lote. Substitua pelas configurações adequadas para os OpenAI modelos.