OpenAImodèles - Amazon Bedrock

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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 :

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.

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.

    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 :

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

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

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)

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

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

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.