Genera risposte utilizzando OpenAI APIs - Amazon Bedrock
Regioni ed endpoint supportatiPrerequisitiModelli (API)API di rispostaAPI per il completamento della chat

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

Genera risposte utilizzando OpenAI APIs

Amazon Bedrock fornisce endpoint API OpenAI compatibili per l'inferenza dei modelli, con tecnologia Mantle, un motore di inferenza distribuito per la creazione di modelli di machine learning su larga scala. Questi endpoint ti consentono di utilizzare strumenti familiari con i modelli Amazon Bedrock, consentendoti di migrare le applicazioni esistenti con modifiche OpenAI SDKs minime al codice: è sufficiente aggiornare l'URL di base e la chiave API.

I vantaggi principali includono:

  • Inferenza asincrona: supporto per carichi di lavoro di inferenza a lunga durata tramite l'API Responses

  • Gestione delle conversazioni con stato: ricostruisci automaticamente il contesto senza passare manualmente la cronologia delle conversazioni ad ogni richiesta

  • Utilizzo semplificato degli strumenti: integrazione semplificata per flussi di lavoro agentici

  • Modalità di risposta flessibili: supporto per risposte in streaming e non in streaming

  • Migrazione semplice: compatibile con le basi di codice OpenAI SDK esistenti

Regioni ed endpoint supportati

Amazon Bedrock è disponibile nelle seguenti AWS regioni:

Nome della regione Regione Endpoint
Stati Uniti orientali (Ohio) us-east-2 bedrock-mantle.us-east-2.api.aws
Stati Uniti orientali (Virginia settentrionale) us-east-1 bedrock-mantle.us-east-1.api.aws
Stati Uniti occidentali (Oregon) us-west-2 bedrock-mantle.us-west-2.api.aws
Asia Pacifico (Giacarta) ap-southeast-3 bedrock-mantle.ap-southeast-3.api.aws
Asia Pacifico (Mumbai) ap-south-1 bedrock-mantle.ap-south-1.api.aws
Asia Pacifico (Tokyo) ap-northeast-1 bedrock-mantle.ap-northeast-1.api.aws
Europa (Francoforte) eu-central-1 bedrock-mantle.eu-central-1.api.aws
Europa (Irlanda) eu-west-1 bedrock-mantle.eu-west-1.api.aws
Europa (Londra) eu-west-2 bedrock-mantle.eu-west-2.api.aws
Europe (Milan) eu-south-1 bedrock-mantle.eu-south-1.api.aws
Europa (Stoccolma) eu-north-1 bedrock-mantle.eu-north-1.api.aws
Sud America (San Paolo) sa-east-1 bedrock-mantle.sa-east-1.api.aws

Prerequisiti

Prima dell'uso, assicurati di avere quanto segue: OpenAI APIs

  • Autenticazione: puoi autenticarti utilizzando:

    • Chiave API Amazon Bedrock (richiesta per OpenAI SDK)

    • AWScredenziali (supportate per le richieste HTTP)

  • OpenAISDK (opzionale): installa l'SDK OpenAI Python se utilizzi richieste basate su SDK.

  • Variabili di ambiente: imposta le seguenti variabili di ambiente:

    • OPENAI_API_KEY— Imposta sulla tua chiave API Amazon Bedrock

    • OPENAI_BASE_URL— Impostato sull'endpoint Amazon Bedrock per la tua regione (ad esempio,) https://bedrock-mantle.us-east-1.api.aws/v1

Modelli (API)

L'API Models ti consente di scoprire i modelli disponibili in Amazon Bedrock con tecnologia Mantle. Usa questa API per recuperare un elenco di modelli che puoi utilizzare con l'API Responses e l'API Chat Completions. Per i dettagli completi sull'API, consulta la documentazione dei OpenAImodelli.

Elenca i modelli disponibili

Per elencare i modelli disponibili, scegli la scheda corrispondente al metodo che preferisci, 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

Effettua una richiesta GET a/v1/models:

# 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"

API di risposta

L'API Responses fornisce una gestione statica delle conversazioni con supporto per lo streaming, l'elaborazione in background e le interazioni a turni multipli. Per i dettagli completi sull'API, consulta la documentazione di ResponsesOpenAI.

Richiesta di base

Per creare una risposta, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

OpenAI SDK (Python)
# Create a basic response using the OpenAI SDK
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input=[
        {"role": "user", "content": "Hello! How can you help me today?"}
    ]
)

print(response)
HTTP request

Fai una richiesta POST a/v1/responses:

# Create a basic response
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

curl -X POST $OPENAI_BASE_URL/responses \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $OPENAI_API_KEY" \
   -d '{
    "model": "openai.gpt-oss-120b",
    "input": [
        {"role": "user", "content": "Hello! How can you help me today?"}
    ]
}'

Risposte in streaming

Per ricevere gli eventi di risposta in modo incrementale, scegli la scheda corrispondente al tuo metodo preferito, quindi segui i passaggi:

OpenAI SDK (Python)
# Stream response events incrementally using the OpenAI SDK
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

from openai import OpenAI

client = OpenAI()

stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input=[{"role": "user", "content": "Tell me a story"}],
    stream=True
)

for event in stream:
    print(event)
HTTP request

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

# Stream response events incrementally
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables

curl -X POST $OPENAI_BASE_URL/responses \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $OPENAI_API_KEY" \
   -d '{
    "model": "openai.gpt-oss-120b",
    "input": [
        {"role": "user", "content": "Tell me a story"}
    ],
    "stream": true
}'

API per il completamento della chat

L'API Chat Completions genera risposte conversazionali. Per i dettagli completi sull'API, consulta la documentazione OpenAIChat Completions.

Creare un completamento di chat

Per creare il completamento di una chat, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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

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

Abilita lo streaming

Per ricevere le 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
}'