Invoque um modelo com a API OpenAI Chat Completions - Amazon Bedrock
Modelos e regiões compatíveisPré-requisitosCriar uma conclusão de bate-papoIncluir uma grade de proteção na conclusão de um bate-papo

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

Invoque um modelo com a API OpenAI Chat Completions

Você pode executar a inferência de modelos usando a API de conclusão de chat OpenAI Create com modelos do Amazon Bedrock.

Você pode chamar a API de conclusão de chat Create das seguintes formas:

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

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

Selecione um tópico para saber mais:

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

Você pode usar a API de conclusão de chat Create com todos os OpenAI modelos compatíveis com o Amazon Bedrock e nas AWS regiões que oferecem suporte a esses modelos. Para obter mais informações sobre modelos e regiões compatíveis, consulteModelos 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 do seu método preferido e siga as etapas:

OpenAI SDK
HTTP request

Criar uma conclusão de bate-papo

Consulte os seguintes recursos na OpenAI documentação para obter detalhes sobre a API Create Chat Completion:

nota

No momento, o Amazon Bedrock não oferece suporte às outras operações da API de conclusão do OpenAI Chat.

Para saber como usar a API de conclusão de chat OpenAI Create, escolha a guia do seu método preferido e siga as etapas:

OpenAI SDK (Python)

Para criar uma conclusão de bate-papo com o OpenAI SDK, faça o seguinte:

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

    • base_url— Prefixe o endpoint do Amazon Bedrock Runtime para/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 valores-chave nesse objeto. Como alternativa, você pode especificar cabeçalhos no extra_headers ao fazer uma chamada de API específica.

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

O exemplo a seguir chama a API de conclusão de bate-papo Create emus-west-2. $AWS_BEARER_TOKEN_BEDROCKSubstitua pela 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 uma conclusão de bate-papo com uma solicitação HTTP direta, 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 AWS credenciais ou uma chave de API do Amazon Bedrock no cabeçalho. Authorization

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

O exemplo a seguir usa curl para chamar a API de conclusão de bate-papo Create emus-west-2. $AWS_BEARER_TOKEN_BEDROCKSubstitua pela 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 grade de proteção na conclusão de um bate-papo

Para incluir proteções na entrada e nas respostas do modelo, aplique uma grade 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— Mapeia para um objeto contendo os seguintes campos, que especificam cabeçalhos extras na solicitação:

    • X-Amzn-Bedrock-GuardrailIdentifier(obrigatório) — O ID da grade de proteção.

    • X-Amzn-Bedrock-GuardrailVersion(obrigatório) — A versão do guarda-corpo.

    • X-Amzn-Bedrock-Trace(opcional) — Se deve ou não ativar o rastreamento do guarda-corpo.

  • extra_body— Mapeia para um objeto. Nesse objeto, você pode incluir o amazon-bedrock-guardrailConfig campo, que mapeia para um objeto contendo os seguintes campos:

Para obter mais informações sobre esses parâmetros no Amazon Bedrock Guardrails, consulte. Teste sua grade de proteção

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);