Invocation d’un modèle avec l’API OpenAI Chat Completions - Amazon Bedrock
Modèles et régions pris en chargeConditions préalablesCreate a chat completionInclusion d’une barrière de protection lors de l’achèvement d’une discussion

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

Vous pouvez exécuter l’inférence de modèles à l’aide de l’API OpenAI Create chat completion 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 :

Modèles et régions pris en charge pour l’API OpenAI Chat Completions

Vous pouvez utiliser l’API Create chat completion avec tous les modèles OpenAI pris en charge dans Amazon Bedrock et dans les régions AWS 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.

Conditions préalables à l’utilisation de l’API Chat Completions

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
HTTP request

Create a chat completion

Reportez-vous aux ressources suivantes de la documentation OpenAI pour plus de détails sur l’API Create chat completion :

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.

  2. 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. Remplacez $AWS_BEARER_TOKEN_BEDROCK 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

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

  3. 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. Remplacez $AWS_BEARER_TOKEN_BEDROCK 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

Pour inclure des protections dans l’entrée et les réponses du modèle, appliquez une barrière de protection lors de l’exécution de l’invocation du modèle en incluant les paramètres supplémentaires 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 :

Pour plus d’informations sur ces paramètres dans les barrières de protection Amazon Bedrock, consultez Test de votre barrière de protection.

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