View a markdown version of this page

Inferenza utilizzando l'API Chat Completions - Amazon Bedrock
Completamento della chat con l'endpoint bedrock-mantleCompletamenti della chat con l'endpoint bedrock-runtimeIncludi un guardrail

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

Inferenza utilizzando l'API Chat Completions

L'API OpenAI Chat Completions genera risposte conversazionali utilizzando i modelli Amazon Bedrock. Puoi utilizzare l'API Chat Completions sia sugli endpoint che sugli endpoint. bedrock-mantle bedrock-runtime Ti consigliamo di utilizzare l'bedrock-mantleendpoint ogni volta che è possibile. Per i dettagli completi sull'API, consulta la documentazione OpenAIChat Completions.

Endpoint URL di base Autenticazione
bedrock-mantle (consigliato) https://bedrock-mantle.{region}.api.aws/v1/chat/completions Chiave o AWS credenziali API Amazon Bedrock
bedrock-runtime https://bedrock-runtime.{region}.amazonaws.com/v1/chat/completions AWS credenziali (SigV4) o chiave API Amazon Bedrock

Ogni endpoint ha le proprie quote di token per modello. Per i dettagli sulle quote applicate al traffico su ciascun endpoint, consulta e. Quote per l'endpoint del substrato roccioso Quote per l'endpoint bedrock-runtime

Completamento della chat con l'endpoint bedrock-mantle

L'bedrock-mantleendpoint supporta l'autenticazione con chiave API Amazon Bedrock e l'OpenAISDK.

Elenca i modelli disponibili

Per elencare i modelli disponibili sull'bedrock-mantleendpoint, scegli la scheda relativa al tuo metodo preferito, quindi segui i passaggi:

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"

Creare un completamento di chat

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

OpenAI SDK (Python)

Configura il OpenAI client utilizzando le variabili di ambiente:

# 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

Fai una richiesta POST a/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

Per ricevere risposte in modo incrementale, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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

Effettua una richiesta POST a /v1/chat/completions with stream set totrue:

# 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
}'

Completamenti della chat con l'endpoint bedrock-runtime

L'bedrock-runtimeendpoint supporta l'autenticazione AWS SigV4 e l'autenticazione con chiave API Amazon Bedrock.

Elenca i modelli disponibili

Per elencare i modelli disponibili sull'bedrock-runtimeendpoint, scegli la scheda relativa al tuo metodo preferito, quindi segui i passaggi:

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"

Creare un completamento di chat

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

OpenAI SDK (Python)

Configura il OpenAI client in modo che punti all'bedrock-runtimeendpoint:

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

Per maggiori dettagli sui modelli, le regioni e le funzionalità avanzate dell'bedrock-runtimeendpoint supportati, consulta. API Chat Completions (riferimento precedente)

Includere un guardrail in un completamento di 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 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:

Per ulteriori informazioni sui questi parametri in Guardrail per Amazon Bedrock, consulta Testare il guardrail.

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