View a markdown version of this page

Inférence à l'aide de l'API Chat Completions - Amazon Bedrock
Terminaison du chat avec le point de terminaison Bedrock-MantleAchèvement des discussions avec le point de terminaison bedrock-runtimeInclure un garde-corps

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

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.

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

Terminaison du chat avec le point de terminaison Bedrock-Mantle

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

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

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

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

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

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, consultezAPI Chat Completions (ancienne référence).

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