Invoquer 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 complétion avec les modèles Amazon Bedrock.

Vous pouvez appeler l'API Create Chat Completion des manières suivantes :

• Effectuez une requête HTTP avec un point de terminaison Amazon Bedrock Runtime.

• Utilisez une demande de OpenAI SDK avec un point de terminaison Amazon Bedrock Runtime.

Sélectionnez un sujet 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 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 les régions pris en charge, consultezModèles de fondation pris en charge dans Amazon Bedrock.

Conditions requises pour utiliser l'API Chat Completions

Pour connaître les conditions requises pour utiliser l'API Chat Completions, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :

OpenAI SDK

• Authentification — Le 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, consultezGénérez des clés d'API Amazon Bedrock pour vous authentifier facilement auprès de l'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.

• Accès au modèle : demandez l'accès à un modèle Amazon Bedrock compatible avec cette fonctionnalité. Pour de plus amples informations, veuillez consulter Ajouter ou supprimer l'accès aux modèles de fondation Amazon Bedrock.

• Installer un OpenAI SDK — Pour plus d'informations, consultez la section Bibliothèques dans la OpenAI documentation.

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é.

  • 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.

• 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.

• Accès au modèle : demandez l'accès à un modèle Amazon Bedrock compatible avec cette fonctionnalité. Pour de plus amples informations, veuillez consulter Ajouter ou supprimer l'accès aux modèles de fondation Amazon Bedrock.

Créer une fin de chat

Consultez les ressources suivantes de la OpenAI documentation pour plus de détails sur l'API de fin de chat Create Chat :

• Paramètres du corps de la demande

• Paramètres du corps de réponse

Note

Amazon Bedrock ne prend actuellement pas en charge les autres opérations de l'API de fin de OpenAI chat.

Pour savoir comment utiliser 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)

Pour terminer le chat avec le OpenAI SDK, procédez comme suit :

1. Importez le OpenAI SDK et configurez le client avec les champs suivants :

   • base_url— Préfixez le point de terminaison Amazon Bedrock Runtime à/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 le extra_headers lorsque vous effectuez un appel d'API spécifique.

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

L'exemple suivant appelle l'API Create chat completion dansus-west-2. $AWS_BEARER_TOKEN_BEDROCKRemplacez-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 terminer le chat à l'aide d'une requête HTTP directe, procédez comme suit :

1. Spécifiez l'URL en préfixant le point de terminaison Amazon Bedrock Runtime comme suit : /openai/v1/chat/completions

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

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

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

L'exemple suivant utilise curl pour appeler l'API Create chat completion dansus-west-2. $AWS_BEARER_TOKEN_BEDROCKRemplacez-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!"
        }
    ]
}'

Inclure un garde-corps dans la fin d'une discussion

Pour inclure des garanties dans la saisie et les réponses du modèle, appliquez un garde-fou 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) — L'identifiant du garde-corps.

  • X-Amzn-Bedrock-GuardrailVersion(obligatoire) — La version du garde-corps.

  • X-Amzn-Bedrock-Trace(facultatif) — S'il faut activer ou non le traçage du garde-corps.

• extra_body— Met en correspondance avec un objet. Dans cet objet, vous pouvez inclure le amazon-bedrock-guardrailConfig champ, qui correspond à un objet contenant les champs suivants :

  • tagSuffix(facultatif) — Incluez ce champ pour le balisage des entrées.

Pour plus d'informations sur ces paramètres dans Amazon Bedrock Guardrails, consultez. Testez votre garde-corps

Pour voir des exemples d'utilisation de barrières de sécurité pour terminer 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);