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.

# Inférence à l'aide de l'API Chat Completions
<a name="inference-chat-completions-mantle"></a>

L'API OpenAI Chat Completions génère des réponses conversationnelles à l'aide des modèles Amazon Bedrock. Vous pouvez utiliser l'API Chat Completions à la fois sur les points de `bedrock-runtime` terminaison `bedrock-mantle` et. Nous vous recommandons d'utiliser le `bedrock-mantle` point de terminaison dans la mesure du possible. Pour obtenir des informations complètes sur l'API, consultez la [documentation OpenAI Chat Completions.](https://developers.openai.com/api/reference/chat-completions/overview)


| **Point de terminaison** | **URL de base** | **Authentification** | 
| --- | --- | --- | 
| bedrock-mantle (recommandé) | https://bedrock-mantle.{region}.api.aws/v1/chat/completions | Clé d'API ou AWS informations d'identification Amazon Bedrock | 
| bedrock-runtime | https://bedrock-runtime.{region}.amazonaws.com/v1/chat/completions | AWS informations d'identification (SigV4) ou clé d'API Amazon Bedrock | 

Chaque point de terminaison possède ses propres quotas de jetons par modèle. Pour plus de détails sur les quotas appliqués au trafic sur chaque point de terminaison, consultez [Quotas pour la limite entre le substrat rocheux et le manteau](quotas-mantle.md) et[Quotas pour le point de terminaison entre le socle et le temps d'exécution](quotas-runtime.md).

## Terminaison du chat avec le point de terminaison Bedrock-Mantle
<a name="inference-chat-completions-mantle-endpoint"></a>

Le `bedrock-mantle` point de terminaison prend en charge l'authentification par clé d'API Amazon Bedrock et le OpenAI SDK.

### Liste des modèles disponibles
<a name="inference-chat-completions-mantle-list-models"></a>

Pour répertorier les modèles disponibles sur le `bedrock-mantle` terminal, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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

```
# List all available models using the OpenAI SDK
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

from openai import OpenAI

client = OpenAI()

models = client.models.list()

for model in models.data:
    print(model.id)
```

------
#### [ HTTP request ]

```
# List all available models
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

curl -X GET $OPENAI_BASE_URL/models \
   -H "Authorization: Bearer $OPENAI_API_KEY"
```

------

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

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

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

Configurez le OpenAI client à l'aide de variables d'environnement :

```
# Create a chat completion using the OpenAI SDK
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="openai.gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ]
)

print(completion.choices[0].message)
```

------
#### [ HTTP request ]

Faites une demande POST pour `/v1/chat/completions` :

```
# Create a chat completion
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

curl -X POST $OPENAI_BASE_URL/chat/completions \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $OPENAI_API_KEY" \
   -d '{
    "model": "openai.gpt-oss-120b",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ]
}'
```

------

**Streaming**  
Pour recevoir des réponses de manière incrémentielle, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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

```
# Stream chat completion responses incrementally using the OpenAI SDK
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="openai.gpt-oss-120b",
    messages=[{"role": "user", "content": "Tell me a story"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="")
```

------
#### [ HTTP request ]

Envoyez une requête POST à `/v1/chat/completions` avec la `stream` valeur définie sur `true` :

```
# Stream chat completion responses incrementally
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

curl -X POST $OPENAI_BASE_URL/chat/completions \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $OPENAI_API_KEY" \
   -d '{
    "model": "openai.gpt-oss-120b",
    "messages": [
        {"role": "user", "content": "Tell me a story"}
    ],
    "stream": true
}'
```

------

## Achèvement des discussions avec le point de terminaison bedrock-runtime
<a name="inference-chat-completions-runtime-endpoint"></a>

Le `bedrock-runtime` point de terminaison prend en charge l'authentification AWS SigV4 et l'authentification par clé d'API Amazon Bedrock.

### Liste des modèles disponibles
<a name="inference-chat-completions-runtime-list-models"></a>

Pour répertorier les modèles disponibles sur le `bedrock-runtime` terminal, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

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

```
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://bedrock-runtime.us-east-1.amazonaws.com/v1",
    api_key=os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
)

models = client.models.list()
for model in models.data:
    print(model.id)
```

------
#### [ HTTP request ]

```
curl -X GET "https://bedrock-runtime.us-east-1.amazonaws.com/v1/models" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK"
```

------

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

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

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

Configurez le OpenAI client pour qu'il pointe vers le point de `bedrock-runtime` terminaison :

```
from openai import OpenAI
import os

client = OpenAI(
    base_url="https://bedrock-runtime.us-east-1.amazonaws.com/v1",
    api_key=os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
)

response = client.chat.completions.create(
    model="us.anthropic.claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
```

------
#### [ HTTP request (API key) ]

```
curl -X POST "https://bedrock-runtime.us-east-1.amazonaws.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
  -d '{
    "model": "us.anthropic.claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

------
#### [ HTTP request (SigV4) ]

```
curl -X POST "https://bedrock-runtime.us-east-1.amazonaws.com/v1/chat/completions" \
  -H "Content-Type: application/json" \
  --aws-sigv4 "aws:amz:us-east-1:bedrock" \
  --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
  -d '{
    "model": "us.anthropic.claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

------

Pour plus de détails sur les modèles pris en charge, les régions et les fonctionnalités avancées du `bedrock-runtime` terminal, consultez[API Chat Completions (ancienne référence)](inference-chat-completions.md).

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

------