Invocación de un modelo con la API Chat Completions de OpenAI - Amazon Bedrock
Modelos y regiones admitidosRequisitos previosCreación de una finalización de chatInclusión de una barrera de protección en una finalización de 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.

Invocación de un modelo con la API Chat Completions de OpenAI

Puede ejecutar la inferencia de modelos mediante la API Create chat completion de OpenAI con los modelos de Amazon Bedrock.

Puede llamar a la API Create chat completion de las formas siguientes:

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

  • Use una solicitud SDK de OpenAI con un punto de conexión de Tiempo de ejecución de Amazon Bedrock.

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

Modelos y regiones compatibles con la API Chat Completions de OpenAI

Puede usar la API Create chat completion con todos los modelos de OpenAI compatibles con Amazon Bedrock y en las regiones de AWS que admiten estos modelos. Para obtener más información acerca de los modelos y regiones compatibles, consulte Modelos fundacionales compatibles en Amazon Bedrock.

Requisitos previos para usar la API Chat Completions

Para ver los requisitos previos para usar la API Chat Completions, elija la pestaña que corresponda al método que prefiera y, a continuación, siga estos pasos:

OpenAI SDK
HTTP request

Creación de una finalización de chat

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

nota

Amazon Bedrock actualmente no admite las demás operaciones de la API Chat completion de OpenAI.

Para obtener más información sobre cómo usar la API Create chat completion de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:

OpenAI SDK (Python)

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

  1. Importe el SDK de OpenAI y configure el cliente con los siguientes campos:

    • base_url: añada el punto de conexión de Tiempo de ejecución de Amazon Bedrock delante de /openai/v1, como en el siguiente formato:

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

    • api_key: especifique una clave de API de Amazon Bedrock.

    • default_headers: si necesita incluir algún encabezado, puede incluirlo como pares de clave-valor en este objeto. También puede especificar los encabezados en los extra_headers cuando realice una llamada a la API específica.

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

En el siguiente ejemplo, se llama a la API Create chat completion en us-west-2. Sustituya $AWS_BEARER_TOKEN_BEDROCK por su 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" # 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 crear una finalización de chat con una solicitud HTTP directa, haga lo siguiente:

  1. Especifique la URL añadiendo el punto de conexión de Tiempo de ejecución de Amazon Bedrock delante de /openai/v1/chat/completions, como en el siguiente formato:

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

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

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

En el siguiente ejemplo, se usa curl para llamar a la API Create chat completion en us-west-2. Sustituya $AWS_BEARER_TOKEN_BEDROCK por su 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!"
        }
    ]
}'

Inclusión de una barrera de protección en una finalización de 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 de la solicitud:

    • X-Amzn-Bedrock-GuardrailIdentifier (obligatorio): el ID de la barrera de protección.

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

    • X-Amzn-Bedrock-Trace (opcional): si se debe habilitar o no el seguimiento de la barrera de protección.

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

Para obtener más información sobre estos parámetros en Barreras de protección para Amazon Bedrock, consulte Prueba de la barrera de protección.

Para ver ejemplos del uso de barreras de protección con finalizaciones de chat de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga 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);