OpenAImodelli

OpenAIoffre i seguenti modelli a peso aperto:

• gpt-oss-20b— Un modello più piccolo ottimizzato per una latenza inferiore e casi d'uso locali o specializzati.

• gpt-oss-120b— Un modello più grande ottimizzato per la produzione e per casi d'uso generici o ad alto ragionamento.

La tabella seguente riassume le informazioni sui modelli:

Informazioni	gpt-oss-20b	gpt-oss-120b
Data di rilascio	5 agosto 2025	5 agosto 2025
ID del modello	openai.gpt-oss-20b-1:0	openai.gpt-oss-120b-1:0
ID del prodotto	N/D	N/D
Modalità di input supportate	Testo	Testo
Modalità di output supportate	Testo	Testo
Finestra contestuale	128.000	128.000

I OpenAI modelli supportano le seguenti funzionalità:

• Richiamo del modello con le seguenti operazioni:

  • InvokeModel

  • Converse

  • OpenAIAPI per il completamento della chat

• Inferenza in batch con CreateModelInvocationJob.

• Applicazione Guardrails tramite l'uso di intestazioni nelle operazioni di invocazione del modello.

OpenAIcorpo della richiesta

Per informazioni sui parametri nel corpo della richiesta e sulle relative descrizioni, consulta Creare il completamento della chat nella OpenAI documentazione.

Utilizza i campi del corpo della richiesta nei seguenti modi:

• In una richiesta InvokeModelo OpenAI Chat Completions, includi i campi nel corpo della richiesta.

• In una richiesta Converse, procedi come segue:

  • Mappali messages come segue:

    • Per ogni messaggio il cui ruolo èdeveloper, aggiungi la content a SystemContentBlocknell'systemarray.

    • Per ogni messaggio il cui ruolo è user oassistant, aggiungi content a a ContentBlocknel content campo e specifica il role nel role campo di un messaggio nell'messagesarray.

  • Mappate i valori dei seguenti campi ai campi corrispondenti nell'inferenceConfigoggetto:

    Campo OpenAI	Campo converso
    max_completion_tokens	maxTokens
    arresta	Stop Sequences
    temperature	temperature
    top_p	topP

  • Includi qualsiasi altro campo nell'additionalModelRequestFieldsoggetto.

Considerazioni sulla costruzione del corpo della richiesta

• I OpenAI modelli supportano solo l'immissione e l'output di testo.

• Il valore nel model campo deve corrispondere a quello nell'intestazione. Puoi omettere questo campo per farlo compilare automaticamente con lo stesso valore dell'intestazione.

• Il valore nel stream campo deve corrispondere all'operazione API utilizzata. È possibile omettere questo campo per consentire che venga compilato automaticamente con il valore corretto.

  • Se si utilizza InvokeModel, il stream valore deve essere. false

OpenAIcorpo di risposta

Il corpo della risposta per OpenAI i modelli è conforme all'oggetto di completamento della chat restituito daOpenAI. Per ulteriori informazioni sui campi di risposta, consulta L'oggetto di completamento della chat nella OpenAI documentazione.

Nota

Se lo usiInvokeModel, il ragionamento del modello, circondato da <reasoning> tag, precede il contenuto testuale della risposta.

Esempio di utilizzo dei modelli OpenAI

Questa sezione fornisce alcuni esempi di utilizzo dei OpenAI modelli.

Prerequisiti

Prima di provare questi esempi, verificate di aver soddisfatto i prerequisiti:

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

  Nota

  Se utilizzi l'API OpenAI Chat completions, puoi autenticarti solo con una chiave 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. È necessario utilizzare un endpoint associato a una regione supportata dal modello utilizzato nell'esempio.

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

• (Se l'esempio utilizza un SDK) Installa l'SDK: dopo l'installazione, imposta le credenziali predefinite e una regione predefinite. AWS Se non configuri le credenziali predefinite o una regione, dovrai specificarle esplicitamente negli esempi di codice pertinenti. Per ulteriori informazioni sui provider di credenziali standardizzati, consulta AWS SDKs and Tools (fornitori di credenziali standardizzati).

  Nota

  Se utilizzi l'OpenAISDK, puoi autenticarti solo con una chiave API Amazon Bedrock e devi impostare esplicitamente l'endpoint Amazon Bedrock.

Espandi la sezione per l'esempio che vuoi vedere:

OpenAICrea il completamento della chat

Per vedere esempi di utilizzo dell'API OpenAI Create chat completion, scegli la scheda corrispondente al tuo metodo preferito, quindi segui i passaggi:

OpenAI SDK (Python)

Il seguente script Python richiama l'API di completamento della chat Create con Python SDKOpenAI:

from openai import OpenAI

client = OpenAI(
    base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1", 
    api_key="$AWS_BEARER_TOKEN_BEDROCK"
)

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 using curl

Puoi eseguire il seguente comando in un terminale per chiamare l'API Create chat completion usando curl:

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

InvokeModel

Scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi:

Python

import boto3
import json

# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')

# Model ID
model_id = 'openai.gpt-oss-20b-1:0'

# Create the request body
native_request = {
  "model": model_id, # You can omit this field
  "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?"
    }
  ],
  "max_completion_tokens": 150,
  "temperature": 0.7,
  "top_p": 0.9,
  "stream": False # You can omit this field
}

# Make the InvokeModel request
response = client.invoke_model(
    modelId=model_id,
    body=json.dumps(native_request)
)

# Parse and print the message for each choice in the chat completion
response_body = json.loads(response['body'].read().decode('utf-8'))

for choice in response_body['choices']:
    print(choice['message']['content'])

conversare

Quando utilizzi l'API Converse unificata, devi mappare i campi di completamento di OpenAI Create chat al campo corrispondente nel corpo della richiesta Converse.

Ad esempio, confronta il seguente corpo della richiesta di completamento della chat con il corpo della richiesta Converse corrispondente:

Create chat completion request body

{
  "model": "openai.gpt-oss-20b-1:0",
  "messages": [
    {
      "role": "developer",
      "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?"
    }
  ],
  "max_completion_tokens": 150,
  "temperature": 0.7
}

Converse request body

{
    "messages": [
        {
            "role": "user", 
            "content": [
                {
                    "text": "Hello! How can I help you today?"
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "text": "What is the weather like today?"
                }
            ]
        }
    ],
    "system": [
        {
            "text": "You are a helpful assistant."
        }
    ],
    "inferenceConfig": {
        "maxTokens": 150,
        "temperature": 0.7
    }
}

Scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi:

Python

# Use the Conversation API to send a text message to Anthropic Claude.

import boto3
from botocore.exceptions import ClientError

# Initialize the Bedrock Runtime client
client = boto3.client("bedrock-runtime")

# Set the model ID
model_id = "openai.gpt-oss-20b-1:0"

# Set up messages and system message
messages = [
    {
        "role": "assistant", 
        "content": [
            {
                "text": "Hello! How can I help you today?"
            }
        ]
    },
    {
        "role": "user",
        "content": [
            {
                "text": "What is the weather like today?"
            }
        ]
    }
]

system = [
    {
        "text": "You are a helpful assistant."
    }
]

try:
    # Send the message to the model, using a basic inference configuration.
    response = client.converse(
        modelId=model_id,
        messages=messages,
        system=system,
        inferenceConfig={
            "maxTokens": 150, 
            "temperature": 0.7, 
            "topP": 0.9
        },
    )

    # Extract and print the response text.
    for content_block in response["output"]["message"]["content"]:
        print(content_block)

except (ClientError, Exception) as e:
    print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
    exit(1)

Guardrail con InvokeModel

Applica un guardrail quando esegui l'invocazione del modello specificando l'ID del guardrail, la versione e se abilitare o meno la traccia del guardrail nell'intestazione di una richiesta di invocazione del modello.

Scegliete la scheda relativa al metodo preferito, quindi seguite i passaggi:

Python

import boto3
from botocore.exceptions import ClientError
import json

# Initiate the Amazon Bedrock Runtime client
bedrock_runtime = boto3.client("bedrock-runtime")

# Model ID
model_id = "openai.gpt-oss-20b-1:0"

# Replace with actual values from your guardrail
guardrail_id = "GR12345"
guardrail_version = "DRAFT"

# Create the request body
native_request = {
  "model": model_id, # You can omit this field
  "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?"
    }
  ],
  "max_completion_tokens": 150,
  "temperature": 0.7,
  "top_p": 0.9,
  "stream": False # You can omit this field
}

try:
    response = bedrock_runtime.invoke_model(
        modelId=model_id,
        body=json.dumps(native_request),
        guardrailIdentifier=guardrail_id,
        guardrailVersion=guardrail_version,
        trace='ENABLED',
    )
    response_body = json.loads(response.get('body').read())
    print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
    print(json.dumps(response_body, indent=2))

except ClientError as err:
    print("RequestId = " + err.response['ResponseMetadata']['RequestId'])
    raise err

Guardrail con OpenAI completamento della chat

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

Inferenza in batch

L'inferenza in batch consente di eseguire l'inferenza del modello in modo asincrono con più prompt. Per eseguire l'inferenza in batch con un modello, effettuate le seguenti operazioni: OpenAI

1. Create un file JSONL e popolatelo con almeno il numero minimo di oggetti JSON, ciascuno separato da una nuova riga. Ogni modelInput oggetto deve essere conforme al formato del corpo della richiesta di completamento della OpenAIcreazione della chat. Di seguito viene mostrato un esempio delle prime due righe di un file JSONL contenente i corpi di richiesta per. OpenAI

   {
       "recordId": "RECORD1", 
       "modelInput": {
           "messages": [
               {
                   "role": "system", 
                   "content": "You are a helpful assistant."
               }, 
               {
                   "role": "user", 
                   "content": "Can you generate a question with a factual answer?"
               }
           ], 
           "max_completion_tokens": 1000
       }
   }
   {
       "recordId": "RECORD2", 
       "modelInput": {
           "messages": [
               {
                   "role": "system", 
                   "content": "You are a helpful assistant."
               }, 
               {
                   "role": "user", 
                   "content": "What is the weather like today?"
               }
           ], 
           "max_completion_tokens": 1000
       }
   }
   ...

   Nota

   Il model campo è facoltativo perché il servizio di inferenza in batch lo inserirà automaticamente in base all'intestazione se lo si omette.

   Verifica che il tuo file JSONL sia conforme alle quote di inferenza in batch come indicato in. Formatta e carica i dati di inferenza in batch

2. Carica il file in un bucket Amazon S3.

3. Invia una CreateModelInvocationJobrichiesta con un endpoint del piano di controllo Amazon Bedrock con il bucket S3 del passaggio precedente specificato nel inputDataConfig campo e il OpenAI modello specificato nel campo. modelId

Per un esempio di end-to-end codice, consulta. Esempio di codice per l'inferenza in batch Sostituire con le configurazioni appropriate per i OpenAI modelli.