OpenAIModelos de - Amazon Bedrock
Cuerpo de la solicitud OpenAICuerpo de la respuesta de OpenAIEjemplo de uso de modelos de OpenAI

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.

OpenAIModelos de

OpenAI ofrece los siguientes modelos de ponderación abierta:

  • gpt-oss-20b: un modelo más pequeño optimizado para una latencia más baja y para casos de uso locales o especializados.

  • gpt-oss-120b: un modelo más grande optimizado para casos de uso de producción y de uso general o de alto razonamiento.

En la siguiente tabla se resume la información de estos modelos:

Información gpt-oss-20b gpt-oss-120b
Fecha de lanzamiento de la nueva versión 5 de agosto de 2025 5 de agosto de 2025
ID del modelo openai.gpt-oss-20b-1:0 openai.gpt-oss-120b-1:0
ID de producto N/A N/A
Modalidades de entrada admitidas Texto Texto
Modalidades de salida admitidas Texto Texto
Ventana de contexto 128 000 128 000

Los modelos de OpenAI admiten las siguientes características:

Cuerpo de la solicitud OpenAI

Para obtener información sobre los parámetros del cuerpo de la solicitud y sus descripciones, consulte Create chat completion en la documentación de OpenAI.

Utilice los campos del cuerpo de la solicitud de las siguientes maneras:

  • En una solicitud InvokeModel o Chat Completions de OpenAI, incluya los campos en el cuerpo de la solicitud.

  • En una solicitud Converse, haga lo siguiente:

    • Asigne el elemento messages como se indica a continuación:

      • Para cada mensaje cuyo rol sea developer, añada al elemento content un SystemContentBlock en la matriz system.

      • Para cada mensaje cuyo rol sea user o assistant, añada el elemento content a un ContentBlock en el campo content y especifique el elemento role en el campo role de un mensaje en la matriz messages.

    • Asigne los valores de los siguientes campos a los campos correspondientes del objeto inferenceConfig:

      OpenAICampo de Campo Converse
      max_completion_tokens maxTokens
      parar stopSequences
      temperature temperature
      top_p topP

    • Incluya todos los demás campos en el objeto additionalModelRequestFields.

Consideraciones al crear el cuerpo de la solicitud

  • Los modelos de OpenAI solo admiten la entrada y salida de texto.

  • El valor del campo model debe coincidir con el del encabezado. Puede omitir este campo para que se rellene automáticamente con el mismo valor que el encabezado.

  • El valor del campo stream debe coincidir con la operación de API que utilice. Puede omitir este campo para que se rellene automáticamente con el valor correcto.

    • Si usa InvokeModel, el valor de stream debe ser false.

Cuerpo de la respuesta de OpenAI

El cuerpo de la respuesta de los modelos de OpenAI se ajusta al objeto de finalización del chat devuelto por OpenAI. Para obtener más información acerca de los campos de respuesta, consulte The chat completion object en la documentación de OpenAI.

nota

Si usa InvokeModel, el razonamiento del modelo, rodeado por las etiquetas <reasoning>, precede al contenido textual de la respuesta.

Ejemplo de uso de modelos de OpenAI

En esta sección se proporcionan algunos ejemplos de cómo utilizar los modelos de OpenAI.

Antes de probar estos ejemplos, asegúrese de haber satisfecho los requisitos previos:

  • Autenticación: puede autenticarse con sus credenciales de AWS o con una clave de API de Amazon Bedrock.

    Configure sus credenciales de AWS o genere una clave de API de Amazon Bedrock para autenticar la solicitud.

    nota

    Si utiliza la API Chat completions de OpenAI, solo puede autenticarse con una clave de API de Amazon Bedrock.

  • Punto de conexión: busque el punto de conexión que corresponda a la región de AWS que desea usar en Puntos de conexión y cuotas de Tiempo de ejecución de Amazon Bedrock. Si usa un SDK de AWS, es posible que solo necesite especificar el código de región y no todo el punto de conexión al configurar el cliente. Debe usar un punto de conexión asociado a una región compatible con el modelo utilizado en el ejemplo.

  • Acceso al modelo: solicite el acceso a un modelo de OpenAI. Para obtener más información, consulte Acceda a los modelos de bases Amazon Bedrock en AWS GovCloud (EE. UU.).

  • (Si el ejemplo usa un SDK) Instale el SDK: después de la instalación, configure las credenciales predeterminadas y una región de AWS predeterminada. Si no configura las credenciales predeterminadas o una región, tendrá que especificarlas de forma explícita en los ejemplos de código correspondientes. Para obtener más información sobre los proveedores de credenciales estandarizados, consulte Proveedores de credenciales estandarizados de SDK y herramientas de AWS.

    nota

    Si usa el SDK de OpenAI, solo puede autenticarse con una clave de API de Amazon Bedrock y debe configurar explícitamente el punto de conexión de Amazon Bedrock.

Amplíe la sección para ver el ejemplo que desee:

Para ver ejemplos del uso de la API Create chat completion de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:

OpenAI SDK (Python)

El siguiente script de Python llama a la API Create chat completion con el SDK de Python de OpenAI:

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

Puede ejecutar el siguiente comando en una ventana de terminal para llamar a la API Create chat completion mediante 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!"
        }
    ]
}'

Elija la pestaña del método que prefiera y siga estos pasos:

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'])

Cuando utiliza la API unificada Converse, debe asignar los campos de Create chat completion de OpenAI a su campo correspondiente en el cuerpo de la solicitud de Converse.

Por ejemplo, compare el siguiente cuerpo de la solicitud de finalización del chat con el cuerpo de la solicitud de Converse correspondiente:

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
    }
}

Elija la pestaña del método que prefiera y siga estos pasos:

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 una barrera de protección al ejecutar la invocación del modelo especificando el ID de la barrera de protección, la versión y si desea habilitar o no el rastreo de la barrera de protección en el encabezado de una solicitud de invocación de modelos.

Elija la pestaña del método que prefiera y siga estos pasos:

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

La inferencia en lotes le permite ejecutar la inferencia de modelos de forma asíncrona con varias peticiones. Para ejecutar la inferencia en lotes con un modelo de OpenAI, haga lo siguiente:

  1. Cree un archivo JSONL y rellénelo con al menos el número mínimo de objetos JSON, cada uno de ellos separado por una nueva línea. Cada objeto modelInput debe ajustarse al formato del cuerpo de la solicitud de create chat completion de OpenAI. A continuación, se muestra un ejemplo de las dos primeras líneas de un archivo JSONL que contiene los cuerpos de las solicitudes de 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

    El campo model es opcional porque el servicio de inferencia en lotes lo insertará automáticamente en función del encabezado si lo omite.

    Compruebe que el archivo JSONL cumpla las cuotas de inferencia en lotes que se indican en Formateo y carga de los datos de la inferencia por lotes.

  2. Cargue el archivo en un bucket de Amazon S3.

  3. Envíe una solicitud CreateModelInvocationJob con un punto de conexión del plano de control de Amazon Bedrock con el bucket de S3 del paso anterior especificado en el campo inputDataConfig y el modelo de OpenAI especificado en el campo modelId.

Si desea obtener un ejemplo de código completo, consulte Ejemplos de código de inferencia en lotes. Sustitúyalo con las configuraciones adecuadas para los modelos de OpenAI.