Modelos de OpenAI

OpenAIofrece los siguientes modelos de peso abierto:

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

La siguiente tabla resume la información sobre los modelos:

Información	gpt-oss-20b	gpt-oss-120b
Fecha de publicació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
Se admiten modalidades de entrada	Texto	Texto
Modalidades de salida compatibles	Texto	Texto
Ventana de contexto	128.000	128.000

Los OpenAI modelos admiten las siguientes funciones:

• Invocación de modelo con las siguientes operaciones:

  • InvokeModel

  • Converse

  • OpenAIAPI para completar el chat

• Inferencia por lotes con CreateModelInvocationJob.

• Preserva la aplicación mediante el uso de encabezados en las operaciones de invocación del modelo.

OpenAIcuerpo de la solicitud

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

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

• En una InvokeModelsolicitud de finalización de OpenAI chat, incluya los campos en el cuerpo de la solicitud.

• En una solicitud de Converse, haga lo siguiente:

  • Mapee messages lo siguiente:

    • Para cada mensaje cuya función seadeveloper, añada la content a SystemContentBlocka la system matriz.

    • Para cada mensaje cuya función sea user oassistant, añada la content a a ContentBlocken el content campo y especifique la role en el role campo de un mensaje de la messages matriz.

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

    Campo OpenAI	Campo inverso
    max_completion_tokens	maxTokens
    parar	stopSequences
    temperature	temperature
    top_p	topP

  • Incluya cualquier otro campo en el objeto. additionalModelRequestFields

Consideraciones a la hora de crear el cuerpo de la solicitud

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

• El valor del model campo 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 stream campo debe coincidir con la operación de API que utilices. Puedes omitir este campo para que se rellene automáticamente con el valor correcto.

  • Si lo usa InvokeModel, el stream valor debe serfalse.

OpenAIcuerpo de respuesta

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

nota

Si lo usaInvokeModel, el razonamiento del modelo, rodeado de <reasoning> etiquetas, precede al contenido textual de la respuesta.

Ejemplo de uso de modelos OpenAI

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

Requisitos previos

Antes de probar estos ejemplos, compruebe que ha cumplido los requisitos previos:

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

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

  • Para obtener más información sobre cómo configurar sus AWS credenciales, consulte Acceso programático con AWS credenciales de seguridad.

  • Para obtener más información sobre las claves de API de Amazon Bedrock y cómo generarlas, consulteGenere claves de API de Amazon Bedrock para autenticarse fácilmente en la API de Amazon Bedrock.

  nota

  Si utilizas la API de finalización de OpenAI chats, solo puedes autenticarte con una clave de API de Amazon Bedrock.

• Punto final: busque el punto de enlace que corresponda a la AWS región para usarlo en los puntos de enlace y las cuotas de Amazon Bedrock Runtime. Si usa un AWS SDK, es posible que solo necesite especificar el código de región y no todo el punto final al configurar el cliente. Debe usar un punto final asociado a una región compatible con el modelo utilizado en el ejemplo.

• Acceso al modelo: solicite el acceso a un OpenAI modelo. Para obtener más información, consulte Adición o eliminación del acceso a los modelos fundacionales de Amazon Bedrock.

• (Si el ejemplo usa un SDK) Instale el SDK: después de la instalación, configure las credenciales predeterminadas y una AWS región predeterminada. Si no configuras las credenciales predeterminadas o una región, tendrás 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 AWS SDKs y Herramientas.

  nota

  Si usa el OpenAI SDK, 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 ver:

OpenAICrea la finalización del chat

Para ver ejemplos del uso de la API OpenAI Create Chats, elige la pestaña del método que prefieras y, a continuación, sigue los pasos:

OpenAI SDK (Python)

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

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

Puedes ejecutar el siguiente comando en una terminal para llamar a la API Create para completar el chat 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!"
        }
    ]
}'

InvokeModel

Elige la pestaña del método que prefieras y, a continuación, sigue los 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'])

Converse

Cuando utilizas la API unificada de Converse, debes asignar los campos para completar el OpenAI chat a su campo correspondiente en el cuerpo de la solicitud de Converse.

Por ejemplo, compara 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
    }
}

Elige la pestaña del método que prefieras y, a continuación, sigue los 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)

Barandillas con InvokeModel

Aplique una barandilla al ejecutar la invocación del modelo especificando el ID de la barandilla, la versión y si se debe habilitar o no el rastreo de la barandilla en el encabezado de una solicitud de invocación de modelo.

Elija la pestaña correspondiente al método que prefiera y, a continuación, 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

Barandillas con OpenAI funciones de chat

Para ver ejemplos del uso de barandillas al finalizar el OpenAI chat, elige la pestaña correspondiente al 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);

Inferencia en lotes

La inferencia por lotes le permite ejecutar la inferencia de modelos de forma asíncrona con múltiples solicitudes. Para ejecutar la inferencia por lotes con un OpenAI modelo, haga lo siguiente:

1. Cree un archivo JSONL y llénelo con al menos el número mínimo de objetos JSON, cada uno separado por una nueva línea. Cada modelInput objeto debe ajustarse al formato del cuerpo de la solicitud de OpenAIcreación de un chat. A continuación se muestra un ejemplo de las dos primeras líneas de un archivo JSONL que contiene los cuerpos de las solicitudes. 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 model campo es opcional porque el servicio de inferencia por lotes lo insertará automáticamente en función del encabezado si lo omite.

   Compruebe que el archivo JSONL cumpla con las cuotas de inferencia por 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 CreateModelInvocationJobsolicitud con un punto final del plano de control de Amazon Bedrock con el bucket S3 del paso anterior especificado en el inputDataConfig campo y el OpenAI modelo especificado en el modelId campo.

Para ver un ejemplo end-to-end de código, consulteEjemplo de código para la inferencia por lotes. Sustitúyalo por las configuraciones adecuadas para los OpenAI modelos.