Invocar um modelo com a API Chat Completions da OpenAI - Amazon Bedrock
Modelos e regiões compatíveisPré-requisitosCriar um preenchimento de chatIncluir uma barreira de proteção em um preenchimento de chat

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á.

Invocar um modelo com a API Chat Completions da OpenAI

Você pode executar a inferência de modelos usando a API Create chat completion da OpenAI com modelos do Amazon Bedrock.

Você pode chamar a API Create chat completion das seguintes maneiras:

  • Faça uma solicitação HTTP com um endpoint do Amazon Bedrock Runtime.

  • Use uma solicitação de SDK da OpenAI com um endpoint do Amazon Bedrock Runtime.

Escolha um tópico para saber mais:

Modelos e regiões compatíveis para a API Chat Completions da OpenAI

É possível usar a API Create chat completion com todos os modelos da OpenAI compatíveis com o Amazon Bedrock e nas regiões da AWS nas quais é possível usar esses modelos. Para ter mais informações sobre modelos e regiões compatíveis, consulte Modelos de base compatíveis no Amazon Bedrock.

Pré-requisitos para usar a API Chat Completions

Para ver os pré-requisitos para usar a API Chat Completions, escolha a guia correspondente ao método de sua preferência e siga as etapas:

OpenAI SDK
HTTP request

Criar um preenchimento de chat

Consulte os seguintes recursos na documentação da OpenAI para obter detalhes sobre a API Create chat completion:

nota

No momento, o Amazon Bedrock não permite outras operações da API Chat Completions da OpenAI.

Para saber como usar a API Create chat completion da OpenAI, escolha a guia correspondente ao método de sua preferência e siga as etapas:

OpenAI SDK (Python)

Para criar um preenchimento de chat com o SDK da OpenAI, faça o seguinte:

  1. Importe o SDK da OpenAI e configure o cliente com os seguintes campos:

    • base_url: prefixe o endpoint do Amazon Bedrock Runtime como /openai/v1, conforme o seguinte formato:

      https://${bedrock-runtime-endpoint}/openai/v1

    • api_key: especifique uma chave de API do Amazon Bedrock.

    • default_headers: se precisar incluir algum cabeçalho, você pode incluí-lo como pares de chave-valor nesse objeto. Ou você pode especificar cabeçalhos em extra_headers ao fazer uma chamada de API específica.

  2. Use o método chat.completions.create() com o cliente e especifique no mínimo model e messages no corpo da solicitação.

O exemplo a seguir chama a API Create chat completion na us-west-2. Substitua $AWS_BEARER_TOKEN_BEDROCK por sua chave de API real.

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

Para criar um preenchimento de chat com uma solicitação HTTP, faça o seguinte:

  1. Especifique o URL prefixando o endpoint do Amazon Bedrock Runtime com /openai/v1/chat/completions, conforme o seguinte formato:

    https://${bedrock-runtime-endpoint}/openai/v1/chat/completions

  2. Especifique suas credenciais da AWS ou uma chave de API do Amazon Bedrock no cabeçalho Authorization.

  3. No corpo da solicitação, especifique pelo menos model e messages no corpo da solicitação.

O exemplo a seguir usa curl para chamar a API Create chat completion na us-west-2. Substitua $AWS_BEARER_TOKEN_BEDROCK por sua chave de API real.

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

Incluir uma barreira de proteção em um preenchimento de chat

Para incluir proteções na entrada e nas respostas do modelo, aplique uma barreira de proteção ao executar a invocação do modelo incluindo os seguintes parâmetros extras como campos no corpo da solicitação:

  • extra_headers: está associado a um objeto que conte´m os seguintes campos, que especificam cabeçalhos extras na solicitação:

    • X-Amzn-Bedrock-GuardrailIdentifier: (obrigatório) o ID da barreira de proteção.

    • X-Amzn-Bedrock-GuardrailVersion: (obrigatório) a versão da barreira de proteção.

    • X-Amzn-Bedrock-Trace: (opcional) se é necessário ou não habilitar o rastreamento da barreira de proteção.

  • extra_body: está associado a um objeto. Nesse objeto, você pode incluir o campo amazon-bedrock-guardrailConfig, que está associado a um objeto que contém os seguintes campos:

Para ter mais informações sobre esses parâmetros nas Barreiras de Proteção do Amazon Bedrock, consulte Testar uma barreira de proteção.

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<ChatCompletion> rawChatCompletionResponse =
        client.chat().completions().withRawResponse().create(request);

final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();

System.out.println(chatCompletion);