Richiama un modello con l'API OpenAI Chat Completions

Puoi eseguire l'inferenza dei modelli utilizzando l'API OpenAI Create chat completion with Amazon Bedrock models.

Puoi chiamare l'API Create chat completion nei seguenti modi:

• Effettua una richiesta HTTP con un endpoint Amazon Bedrock Runtime.

• Utilizza una richiesta OpenAI SDK con un endpoint Amazon Bedrock Runtime.

Seleziona un argomento per saperne di più:

Regioni e modelli supportati per l'API OpenAI Chat Completions

Puoi utilizzare l'API Create chat completion con tutti i OpenAI modelli supportati in Amazon Bedrock e nelle AWS regioni che supportano questi modelli. Per ulteriori informazioni sui modelli e sulle regioni supportati, consultaModelli di fondazione supportati in Amazon Bedrock.

Prerequisiti per utilizzare l'API Chat Completions

Per visualizzare i prerequisiti per l'utilizzo dell'API Chat Completions, scegli la scheda corrispondente al tuo metodo preferito, quindi segui i passaggi:

OpenAI SDK

• Autenticazione: l'OpenAISDK supporta solo l'autenticazione con una chiave API Amazon Bedrock. Genera una chiave API Amazon Bedrock per autenticare la tua richiesta. Per ulteriori informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consultaGenera chiavi API Amazon Bedrock per autenticarti facilmente nell'API Amazon Bedrock.

• Endpoint: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli endpoint e nelle quote di Amazon Bedrock Runtime. Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.

• Accesso al modello: richiedi l'accesso a un modello Amazon Bedrock che supporti questa funzionalità. Per ulteriori informazioni, consulta Aggiungere o rimuovere l'accesso ai modelli Amazon Bedrock Foundation.

• Installa un OpenAI SDK: per ulteriori informazioni, consulta Librerie nella OpenAI documentazione.

HTTP request

• Autenticazione: puoi autenticarti con AWS le tue credenziali o con una chiave API Amazon Bedrock.

  Configura AWS le tue credenziali o genera una chiave API Amazon Bedrock per autenticare la tua richiesta.

  • Per ulteriori informazioni sulla configurazione delle AWS credenziali, consulta Accesso programmatico con credenziali di sicurezza. AWS

  • Per ulteriori informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consultaGenera chiavi API Amazon Bedrock per autenticarti facilmente nell'API Amazon Bedrock.

• Endpoint: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli endpoint e nelle quote di Amazon Bedrock Runtime. Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.

• Accesso al modello: richiedi l'accesso a un modello Amazon Bedrock che supporti questa funzionalità. Per ulteriori informazioni, consulta Aggiungere o rimuovere l'accesso ai modelli Amazon Bedrock Foundation.

Crea un completamento della chat

Fai riferimento alle seguenti risorse nella OpenAI documentazione per i dettagli sull'API Create chat completion:

• Parametri del corpo della richiesta

• Parametri del corpo di risposta

Nota

Amazon Bedrock attualmente non supporta le altre operazioni dell'API di completamento della OpenAI chat.

Per imparare a utilizzare l'API OpenAI Create chat completion, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

OpenAI SDK (Python)

Per creare un completamento della chat con l'OpenAISDK, procedi come segue:

1. Importa l'OpenAISDK e configura il client con i seguenti campi:

   • base_url— Prefissa l'endpoint Amazon Bedrock Runtime con il prefisso/openai/v1, come nel seguente formato:

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

   • api_key— Specificare una chiave API Amazon Bedrock.

   • default_headers— Se devi includere delle intestazioni, puoi includerle come coppie chiave-valore in questo oggetto. In alternativa, è possibile specificare le intestazioni in extra_headers quando si effettua una chiamata API specifica.

2. Utilizzate il chat.completions.create() metodo con il client e specificate minimamente model e messages nel corpo della richiesta.

L'esempio seguente richiama l'API Create chat completion inus-west-2. Sostituiscila $AWS_BEARER_TOKEN_BEDROCK con la tua chiave API effettiva.

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

Per creare un completamento della chat con una richiesta HTTP diretta, procedi come segue:

1. Specificate l'URL aggiungendo come prefisso l'endpoint Amazon Bedrock Runtime/openai/v1/chat/completions, come nel seguente formato:

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

2. Specificate AWS le vostre credenziali o una chiave API Amazon Bedrock nell'Authorizationintestazione.

3. Nel corpo della richiesta, specifica almeno la model e messages nel corpo della richiesta.

L'esempio seguente utilizza curl per chiamare l'API Create chat completion inus-west-2. $AWS_BEARER_TOKEN_BEDROCKSostituiscila con la tua chiave API attuale:

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

Includi un guardrail nel completamento di una chat

Per includere misure di sicurezza nell'input e nelle risposte del modello, applica un guardrail quando esegui l'invocazione del modello includendo i seguenti parametri aggiuntivi come campi nel corpo della richiesta:

• extra_headers— Esegue il mapping su un oggetto contenente i seguenti campi, che specificano intestazioni aggiuntive nella richiesta:

  • X-Amzn-Bedrock-GuardrailIdentifier(obbligatorio) — L'ID del guardrail.

  • X-Amzn-Bedrock-GuardrailVersion(obbligatorio) — La versione del guardrail.

  • X-Amzn-Bedrock-Trace(opzionale) — Se abilitare o meno la traccia del guardrail.

• extra_body— Esegue la mappa su un oggetto. In quell'oggetto, è possibile includere il amazon-bedrock-guardrailConfig campo, che corrisponde a un oggetto contenente i seguenti campi:

  • tagSuffix(opzionale) — Includi questo campo per l'etichettatura di input.

Per ulteriori informazioni su questi parametri in Amazon Bedrock Guardrails, consulta. Metti alla prova il tuo guardrail

Per vedere esempi di utilizzo dei guardrail con il completamento delle OpenAI chat, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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