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.

# Invocation d’un modèle avec l’API OpenAI Chat Completions
<a name="inference-chat-completions"></a>

Vous pouvez exécuter l’inférence de modèles à l’aide de l’[API OpenAI Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) avec les modèles Amazon Bedrock.

Vous pouvez appeler l’API Create chat completion des manières suivantes :
+ Effectuer une requête HTTP avec un point de terminaison d’exécution d’Amazon Bedrock.
+ Utiliser une demande de kit SDK OpenAI avec un point de terminaison d’exécution d’Amazon Bedrock.

Choisissez une rubrique pour en savoir plus :

**Topics**
+ [Modèles et régions pris en charge pour l’API OpenAI Chat Completions](#inference-chat-completions-supported)
+ [Conditions préalables à l’utilisation de l’API Chat Completions](#inference-chat-completions-prereq)
+ [Create a chat completion](#inference-chat-completions-create)
+ [Inclusion d’une barrière de protection lors de l’achèvement d’une discussion](#inference-chat-completions-guardrails)

## Modèles et régions pris en charge pour l’API OpenAI Chat Completions
<a name="inference-chat-completions-supported"></a>

Vous pouvez utiliser l'API Create chat complétion avec tous les OpenAI modèles pris en charge dans Amazon Bedrock et dans les AWS régions qui prennent en charge ces modèles. Pour plus d’informations sur les modèles et régions pris en charge, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).

## Conditions préalables à l’utilisation de l’API Chat Completions
<a name="inference-chat-completions-prereq"></a>

Pour connaître les conditions préalables à l’utilisation de l’API Chat Completions, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

------
#### [ OpenAI SDK ]
+ **Authentification** : le kit OpenAI SDK prend uniquement en charge l’authentification avec une clé d’API Amazon Bedrock. Générez une clé d’API Amazon Bedrock pour authentifier votre demande. Pour en savoir plus sur les clés d'API Amazon Bedrock et sur la façon de les générer, consultez la section Clés d'API du chapitre Build.
+ 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](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). 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.
+ **Installer un kit SDK OpenAI** : pour plus d’informations, consultez [Libraries](https://platform.openai.com/docs/libraries) dans la documentation OpenAI.

------
#### [ HTTP request ]
+ **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é](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html).
  + Pour en savoir plus sur les clés d'API Amazon Bedrock et sur la façon de les générer, consultez la section Clés d'API du chapitre Build.
+ 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](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). 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.

------

## Create a chat completion
<a name="inference-chat-completions-create"></a>

Reportez-vous aux ressources suivantes de la documentation OpenAI pour plus de détails sur l’API Create chat completion :
+ [Paramètres du corps de la demande](https://platform.openai.com/docs/api-reference/chat/create)
+ [Paramètres du corps de réponse](https://platform.openai.com/docs/api-reference/chat/object)

**Note**  
Amazon Bedrock ne prend actuellement pas en charge les autres opérations de l’API OpenAI Chat completion.

Pour découvrir comment utiliser l’API OpenAI Create chat completion, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

------
#### [ OpenAI SDK (Python) ]

Pour créer un achèvement de discussion avec le kit OpenAI SDK, procédez comme suit :

1. Importez le kit OpenAI SDK et configurez le client avec les champs suivants :
   + `base_url` : préfixez le point de terminaison d’exécution d’Amazon Bedrock avec `/openai/v1`, comme dans le format suivant :

     ```
     https://${bedrock-runtime-endpoint}/openai/v1
     ```
   + `api_key` : spécifiez une clé d’API Amazon Bedrock.
   + `default_headers` : si vous devez inclure des en-têtes, vous pouvez les inclure sous forme de paires clé-valeur dans cet objet. Vous pouvez également spécifier des en-têtes dans `extra_headers` lorsque vous effectuez un appel d’API spécifique.

1. Utilisez la méthode `chat.completions.create()` avec le client et spécifiez au minimum `model` et `messages` dans le corps de la demande.

L’exemple suivant appelle l’API Create chat completion dans la région `us-west-2`. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Remplacez-la par votre clé d'API réelle.

```
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 ]

Pour créer un achèvement de discussion par une requête HTTTP directe, procédez comme suit :

1. Spécifiez l’URL en préfixant le point de terminaison d’exécution d’Amazon Bedrock avec `/openai/v1/chat/completions`, comme dans le format suivant :

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

1. Spécifiez vos AWS informations d'identification ou une clé d'API Amazon Bedrock dans l'`Authorization`en-tête.

1. Dans le corps de la demande, spécifiez au moins `model` et `messages` dans le corps de la demande.

L’exemple suivant utilise curl pour appeler l’API Create chat completion dans la région `us-west-2`. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Remplacez-la par votre clé d'API réelle :

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

------

## Inclusion d’une barrière de protection lors de l’achèvement d’une discussion
<a name="inference-chat-completions-guardrails"></a>

Pour inclure des protections dans l’entrée et les réponses du modèle, appliquez une [barrière de protection](guardrails.md) lors de l’exécution de l’invocation du modèle en incluant les [paramètres supplémentaires](https://github.com/openai/openai-python#undocumented-request-params) suivants sous forme de champs dans le corps de la demande :
+ `extra_headers` : correspond à un objet contenant les champs suivants, qui spécifient des en-têtes supplémentaires dans la demande :
  + `X-Amzn-Bedrock-GuardrailIdentifier` (obligatoire) : identifiant de la barrière de protection.
  + `X-Amzn-Bedrock-GuardrailVersion` (obligatoire) : version de la barrière de protection.
  + `X-Amzn-Bedrock-Trace` (facultatif) : indique s’il faut activer ou non le traçage de la barrière de protection.
+ `extra_body` : est mappé à un objet. Dans cet objet, vous pouvez inclure le champ `amazon-bedrock-guardrailConfig`, qui correspond à un objet contenant les champs suivants :
  + `tagSuffix` (facultatif) : incluez ce champ pour le [balisage des entrées](guardrails-tagging.md).

Pour plus d’informations sur ces paramètres dans les barrières de protection Amazon Bedrock, consultez [Test de votre barrière de protection](guardrails-test.md).

Pour voir des exemples d’utilisation de barrière de protection lors de l’achèvement d’une discussion OpenAI, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

------
#### [ 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);
```

------