Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Invocare un modello con l’API Chat Completions OpenAI
<a name="inference-chat-completions"></a>

Per eseguire l’inferenza del modello, è possibile utilizzare l’[API Create chat completion OpenAI](https://platform.openai.com/docs/api-reference/chat/create) con i modelli Amazon Bedrock.

L’API Create chat completion può essere chiamata nei modi seguenti:
+ Effettuare una richiesta HTTP con un endpoint di runtime Amazon Bedrock.
+ Utilizzare una richiesta OpenAI SDK con un endpoint di runtime Amazon Bedrock.

Per ulteriori informazioni, scegli un argomento:

**Topics**
+ [

## Regioni e modelli supportati per l’API Chat Completions OpenAI
](#inference-chat-completions-supported)
+ [

## Prerequisiti per utilizzare l’API Chat Completions
](#inference-chat-completions-prereq)
+ [

## Creare un completamento di chat
](#inference-chat-completions-create)
+ [

## Includere un guardrail in un completamento di chat
](#inference-chat-completions-guardrails)

## Regioni e modelli supportati per l’API Chat Completions OpenAI
<a name="inference-chat-completions-supported"></a>

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 sulle Regioni e sui modelli supportati, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).

## Prerequisiti per utilizzare l’API Chat Completions
<a name="inference-chat-completions-prereq"></a>

Per visualizzare i prerequisiti per l’utilizzo dell’API Chat Completions, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

------
#### [ OpenAI SDK ]
+ **Autenticazione**: OpenAI SDK supporta solo l’autenticazione con una chiave API Amazon Bedrock. Genera una chiave API Amazon Bedrock per autenticare la tua richiesta. Per informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consulta la sezione Chiavi API nel capitolo Build.
+ **Endpoint**: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli [endpoint e nelle quote di Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.
+ **Installa OpenAI SDK**: per ulteriori informazioni, consulta [Librerie](https://platform.openai.com/docs/libraries) nella documentazione OpenAI.

------
#### [ 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) con credenziali di sicurezza. AWS 
  + Per informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consulta la sezione Chiavi API nel capitolo Build.
+ **Endpoint**: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli [endpoint e nelle quote di Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.

------

## Creare un completamento di chat
<a name="inference-chat-completions-create"></a>

Per i dettagli sull’API Create chat completion, consulta le risorse seguenti nella documentazione OpenAI:
+ [Parametri del corpo della richiesta](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parametri del corpo di risposta](https://platform.openai.com/docs/api-reference/chat/object)

**Nota**  
Amazon Bedrock attualmente non supporta le altre operazioni dell’API Chat Completions OpenAI.

Per le modalità di utilizzo dell’API Create chat completion OpenAI, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

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

Per creare un completamento di chat con un SDK OpenAI, esegui queste operazioni:

1. Importa il componente SDK OpenAI e configura il client con i seguenti campi:
   + `base_url`: anteponi l’endpoint di runtime Amazon Bedrock a `/openai/v1`, come nel seguente formato:

     ```
     https://${bedrock-runtime-endpoint}/openai/v1
     ```
   + `api_key`: specifica una chiave API Amazon Bedrock.
   + `default_headers`: se è necessario includere intestazioni, includile come coppie chiave-valore in questo oggetto. In alternativa, puoi specificare le intestazioni in `extra_headers` quando effettui una chiamata API specifica.

1. Utilizza il metodo `chat.completions.create()` con il client e specifica almeno `model` e `messages` nel corpo della richiesta.

L’esempio seguente chiama l’API Create chat completion in `us-west-2`. Sostituiscilo *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* 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, esegui queste operazioni:

1. Specifica l’URL anteponendo l’endpoint di runtime Amazon Bedrock a `/openai/v1/chat/completions`, come nel seguente formato:

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

1. Specificate AWS le vostre credenziali o una chiave API Amazon Bedrock nell'`Authorization`intestazione.

1. Nel corpo della richiesta, specifica almeno `model` e `messages` nel corpo della richiesta.

L’esempio seguente utilizza il comando curl per chiamare l’API Create chat completion in `us-west-2`. Sostituisci *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* con la tua chiave API effettiva:

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

------

## Includere un guardrail in un completamento di chat
<a name="inference-chat-completions-guardrails"></a>

Per includere misure di sicurezza nell’input e nelle risposte del modello, applica un [guardrail](guardrails.md) quando esegui l’invocazione del modello includendo i seguenti [parametri aggiuntivi](https://github.com/openai/openai-python#undocumented-request-params) come campi nel corpo della richiesta.
+ `extra_headers`: esegue il mapping a un oggetto contenente i seguenti campi, che specificano intestazioni aggiuntive nella richiesta:
  + `X-Amzn-Bedrock-GuardrailIdentifier` (obbligatorio): ID del guardrail.
  + `X-Amzn-Bedrock-GuardrailVersion` (obbligatorio): versione del guardrail.
  + `X-Amzn-Bedrock-Trace` (facoltativo): indica se abilitare o meno la traccia del guardrail.
+ `extra_body`: esegue il mapping a un oggetto. In tale oggetto è possibile includere il campo `amazon-bedrock-guardrailConfig`, che viene mappato a un oggetto contenente i campi seguenti:
  + `tagSuffix` (facoltativo): includi questo campo per il[tagging di input](guardrails-tagging.md).

Per ulteriori informazioni sui questi parametri in Guardrail per Amazon Bedrock, consulta [Testare il guardrail](guardrails-test.md).

Per esempi di utilizzo dei guardrail con Chat Completions OpenAI, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

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

------