Invoca un modelo con la API OpenAI Chat Completions - Amazon Bedrock
Modelos y regiones compatiblesRequisitos previosCrea una finalización de chatIncluye una barrera al finalizar el chat

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Invoca un modelo con la API OpenAI Chat Completions

Puede ejecutar la inferencia de modelos mediante la API de finalización de chats OpenAI Create con los modelos de Amazon Bedrock.

Puede llamar a la API Create para completar el chat de las siguientes maneras:

  • Realice una solicitud HTTP con un punto de conexión Amazon Bedrock Runtime.

  • Utilice una solicitud de OpenAI SDK con un punto de conexión Amazon Bedrock Runtime.

Seleccione un tema para obtener más información:

Modelos y regiones compatibles con la API OpenAI Chat Completions

Puede usar la API Create para completar chats con todos los OpenAI modelos compatibles con Amazon Bedrock y en las AWS regiones que admiten estos modelos. Para obtener más información sobre los modelos y las regiones compatibles, consulteModelos fundacionales compatibles en Amazon Bedrock.

Requisitos previos para usar la API Chat Completions

Para ver los requisitos previos para usar la API Chat Completions, elige la pestaña que corresponda al método que prefieras y, a continuación, sigue los pasos:

OpenAI SDK
HTTP request

Crea un chat para completar

Consulte los siguientes recursos de la OpenAI documentación para obtener más información sobre la API Create para completar el chat:

nota

Amazon Bedrock actualmente no admite las demás operaciones de la API de finalización de OpenAI chats.

Para obtener información sobre cómo usar la API OpenAI Create para completar chats, elige la pestaña que corresponda al método que prefieras y, a continuación, sigue estos pasos:

OpenAI SDK (Python)

Para crear una finalización de chat con el OpenAI SDK, haga lo siguiente:

  1. Importa el OpenAI SDK y configura el cliente con los siguientes campos:

    • base_url— Prefije el prefijo del punto final de Amazon Bedrock Runtime a/openai/v1, como en el siguiente formato:

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

    • api_key— Especifique una clave de API de Amazon Bedrock.

  2. Utilice el chat.completions.create() método con el cliente y especifique como mínimo la model y messages en el cuerpo de la solicitud.

En el siguiente ejemplo, se activa la API Create Chat Complete. us-west-2 $AWS_BEARER_TOKEN_BEDROCKSustitúyala por tu clave de API actual:

from openai import OpenAI

client = OpenAI(
    base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1", 
    api_key="$AWS_BEARER_TOKEN_BEDROCK"
)

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 completar un chat con una solicitud HTTP directa, haz lo siguiente:

  1. Especifique la URL añadiendo el prefijo del punto final de Amazon Bedrock Runtime a/openai/v1/chat/completions, como en el siguiente formato:

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

  2. Especifique sus AWS credenciales o una clave de API de Amazon Bedrock en el Authorization encabezado.

  3. En el cuerpo de la solicitud, especifique al menos la model y messages en el cuerpo de la solicitud.

En el siguiente ejemplo, se llama a la API Create Chat Completeus-west-2. $AWS_BEARER_TOKEN_BEDROCKSustitúyala por tu clave de API actual:

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

Incluye una barrera al finalizar el chat

Para incluir medidas de seguridad en las entradas y respuestas del modelo, aplique una barrera de protección al ejecutar la invocación del modelo e incluya los siguientes parámetros adicionales como campos en el cuerpo de la solicitud:

  • extra_headers— Se asigna a un objeto que contiene los siguientes campos, que especifican encabezados adicionales en la solicitud:

    • X-Amzn-Bedrock-GuardrailIdentifier(obligatorio): el identificador de la barandilla.

    • X-Amzn-Bedrock-GuardrailVersion(obligatorio): la versión de la barandilla.

    • X-Amzn-Bedrock-Trace(opcional): si se debe habilitar o no el rastreo de la barandilla.

  • extra_body— Mapea un objeto. En ese objeto, puede incluir el amazon-bedrock-guardrailConfig campo, que se asigna a un objeto que contiene los siguientes campos:

Para obtener más información sobre estos parámetros en Amazon Bedrock Guardrails, consulte. Pon a prueba tu barandilla

Para ver ejemplos del uso de barandillas al finalizar el OpenAI chat, elige la pestaña del método que prefieras y, a continuación, sigue los pasos:

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