OpenAImodèles

OpenAIpropose les modèles à poids ouvert suivants :

• gpt-oss-20b— Un modèle plus petit optimisé pour une latence plus faible et des cas d'utilisation locaux ou spécialisés.

• gpt-oss-120b— Un modèle plus grand optimisé pour la production et les cas d'utilisation à usage général ou exigeant un raisonnement poussé.

Le tableau suivant récapitule les informations relatives aux modèles :

Informations	gpt-oss-20b	gpt-oss-120b
Date de publication	5 août 2025	5 août 2025
ID du modèle	openai.gpt-oss-20b-1:0	openai.gpt-oss-120b-1:0
ID produit	N/A	N/A
Modalités de saisie prises en charge	Texte	Texte
Modalités de sortie prises en charge	Texte	Texte
Fenêtre contextuelle	128 000	128 000

Les OpenAI modèles sont compatibles avec les fonctionnalités suivantes :

• Modèle d'invocation avec les opérations suivantes :

  • InvokeModel

  • Converse

  • OpenAIAPI de complétion des discussions

• Inférence par lots avec CreateModelInvocationJob.

• Maintient l'application grâce à l'utilisation d'en-têtes dans les opérations d'invocation du modèle.

OpenAIcorps de la demande

Pour plus d'informations sur les paramètres du corps de la demande et leurs descriptions, consultez la section Créer une fin de chat dans la OpenAI documentation.

Utilisez les champs du corps de la demande de la manière suivante :

• Dans une demande InvokeModelou OpenAI Chat Completions, incluez les champs dans le corps de la demande.

• Dans une requête Converse, procédez comme suit :

  • Cartographiez le messages comme suit :

    • Pour chaque message dont le rôle estdeveloper, ajoutez le content a SystemContentBlockdans le system tableau.

    • Pour chaque message dont le rôle est user ouassistant, ajoutez le content à a ContentBlockdans le content champ et spécifiez le role dans le role champ d'un message dans le messages tableau.

  • Associez les valeurs des champs suivants aux champs correspondants de l'inferenceConfigobjet :

    OpenAI field	Champ Converse
    max_completion_tokens	maxTokens
    stop	Séquences d'arrêt
    temperature	temperature
    top_p	topP

  • Incluez tout autre champ dans l'additionalModelRequestFieldsobjet.

Considérations relatives à la construction du corps de la demande

• Les OpenAI modèles ne prennent en charge que la saisie et la sortie de texte.

• La valeur du model champ doit correspondre à celle de l'en-tête. Vous pouvez omettre ce champ pour qu'il soit automatiquement rempli avec la même valeur que l'en-tête.

• La valeur du stream champ doit correspondre à l'opération d'API que vous utilisez. Vous pouvez omettre ce champ pour qu'il soit automatiquement renseigné avec la valeur correcte.

  • Si vous utilisez InvokeModel, la stream valeur doit êtrefalse.

OpenAIorganisme de réponse

Le corps de réponse pour les OpenAI modèles est conforme à l'objet de fin de discussion renvoyé parOpenAI. Pour plus d'informations sur les champs de réponse, voir L'objet de fin de discussion dans la OpenAI documentation.

Note

Si vous l'utilisezInvokeModel, le raisonnement du modèle, entouré de <reasoning> balises, précède le contenu textuel de la réponse.

Exemple d'utilisation de OpenAI modèles

Cette section fournit des exemples d'utilisation des OpenAI modèles.

Prérequis

Avant d'essayer ces exemples, vérifiez que vous avez rempli les conditions requises :

• Authentification — Vous pouvez vous authentifier avec vos AWS informations d'identification ou avec une clé d'API Amazon Bedrock.

  Configurez vos AWS informations d'identification ou générez une clé d'API Amazon Bedrock pour authentifier votre demande.

  • Pour en savoir plus sur la configuration de vos AWS informations d'identification, consultez la section Accès par programmation avec informations d'identification AWS de sécurité.

  • Pour en savoir plus sur les clés d'API Amazon Bedrock et sur la façon de les générer, consultezGénérez des clés d'API Amazon Bedrock pour vous authentifier facilement auprès de l'API Amazon Bedrock.

  Note

  Si vous utilisez l'API OpenAI Chat completions, vous ne pouvez vous authentifier qu'avec une clé d'API Amazon Bedrock.

• Point de terminaison : recherchez le point de terminaison correspondant à la AWS région à utiliser dans les points de terminaison et les quotas Amazon Bedrock Runtime. Si vous utilisez un AWS SDK, il se peut que vous deviez uniquement spécifier le code de région et non le point de terminaison complet lors de la configuration du client. Vous devez utiliser un point de terminaison associé à une région prise en charge par le modèle utilisé dans l'exemple.

• Accès au modèle — Demande l'accès à un OpenAI modèle. Pour de plus amples informations, veuillez consulter Ajouter ou supprimer l'accès aux modèles de fondation Amazon Bedrock.

• (Si l'exemple utilise un SDK) Installez le SDK : après l'installation, configurez les informations d'identification par défaut et une région par défaut AWS . Si vous ne configurez pas d'informations d'identification par défaut ou de région, vous devrez les spécifier explicitement dans les exemples de code pertinents. Pour plus d'informations sur les fournisseurs d'informations d'identification standardisées, voir AWS SDKs et Outils fournisseurs d'informations d'identification standardisés.

  Note

  Si vous utilisez le OpenAI SDK, vous ne pouvez vous authentifier qu'avec une clé d'API Amazon Bedrock et vous devez définir explicitement le point de terminaison Amazon Bedrock.

Développez la section correspondant à l'exemple que vous souhaitez voir :

OpenAICréer la fin du chat

Pour voir des exemples d'utilisation de l'API OpenAI Create chat complétion, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

OpenAI SDK (Python)

Le script Python suivant appelle l'API Create chat complétion avec le SDK 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

Vous pouvez exécuter la commande suivante dans un terminal pour appeler l'API Create chat completion à l'aide de 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

Choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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

Lorsque vous utilisez l'API Converse unifiée, vous devez associer les champs de fin de discussion OpenAI Create chat au champ correspondant dans le corps de la requête Converse.

Par exemple, comparez le corps de demande de fin de chat suivant au corps de demande Converse correspondant :

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

Choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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)

Rambardes avec InvokeModel

Appliquez un garde-corps lors de l'exécution de l'invocation du modèle en spécifiant l'ID et la version du garde-corps et en indiquant s'il faut activer ou non le suivi du garde-corps dans l'en-tête d'une demande d'invocation de modèle.

Choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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

Rambardes avec fin de chat OpenAI

Pour voir des exemples d'utilisation de barrières de sécurité lors de la fin d'une OpenAI discussion, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes ci-dessous :

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

Inférence par lots

L'inférence par lots vous permet d'exécuter l'inférence de modèle de manière asynchrone à l'aide de plusieurs invites. Pour exécuter l'inférence par lots avec un OpenAI modèle, procédez comme suit :

1. Créez un fichier JSONL et remplissez-le avec au moins le nombre minimum d'objets JSON, séparés chacun par une nouvelle ligne. Chaque modelInput objet doit être conforme au format du corps de la demande de fin de OpenAI création de chat. Voici un exemple des deux premières lignes d'un fichier JSONL contenant les corps de requête pour. 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
       }
   }
   ...

   Note

   Le model champ est facultatif car le service d'inférence par lots l'insérera pour vous en fonction de l'en-tête si vous l'omettez.

   Vérifiez que votre fichier JSONL est conforme aux quotas d'inférence par lots, comme indiqué dans. Formatez et téléchargez vos données d'inférence par lots

2. Téléchargez le fichier dans un compartiment Amazon S3.

3. Envoyez une CreateModelInvocationJobdemande avec un point de terminaison du plan de contrôle Amazon Bedrock avec le compartiment S3 de l'étape précédente spécifiée dans le inputDataConfig champ et le OpenAI modèle spécifié dans le modelId champ.

Pour un exemple de end-to-end code, voirExemple de code pour l'inférence par lots. Remplacez-le par les configurations appropriées pour les OpenAI modèles.