Rufen Sie ein Modell mit der OpenAI Chat Completions API auf - Amazon Bedrock
Unterstützte Modelle und RegionenVoraussetzungenErstellen Sie einen Chat-AbschlussFügen Sie eine Leitplanke in einen Chat-Abschluss ein

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Rufen Sie ein Modell mit der OpenAI Chat Completions API auf

Sie können Modellinferenzen mithilfe der OpenAICreate Chat Completion API mit Amazon Bedrock-Modellen ausführen.

Sie können die Create Chat Completion API auf folgende Weise aufrufen:

  • Stellen Sie eine HTTP-Anfrage mit einem Amazon Bedrock Runtime-Endpunkt.

  • Verwenden Sie eine OpenAI SDK-Anfrage mit einem Amazon Bedrock Runtime-Endpunkt.

Wählen Sie ein Thema aus, um mehr zu erfahren:

Unterstützte Modelle und Regionen für die OpenAI Chat Completions API

Sie können die Create Chat Completion API mit allen OpenAI Modellen verwenden, die in Amazon Bedrock und in den AWS Regionen unterstützt werden, die diese Modelle unterstützen. Weitere Informationen zu unterstützten Modellen und Regionen finden Sie unterUnterstützte Basismodelle in Amazon Bedrock.

Voraussetzungen für die Verwendung der Chat Completions API

Um die Voraussetzungen für die Verwendung der Chat Completions API zu sehen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:

OpenAI SDK
HTTP request

Erstellen Sie einen Chat-Abschluss

Einzelheiten zur Create Chat Completion API finden Sie in den folgenden Ressourcen in der OpenAI Dokumentation:

Anmerkung

Amazon Bedrock unterstützt derzeit die anderen API-Operationen zur OpenAI Chat-Vervollständigung nicht.

Um zu erfahren, wie Sie die OpenAI Create Chat Completion API verwenden können, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:

OpenAI SDK (Python)

Gehen Sie wie folgt vor, um einen Chat-Abschluss mit dem OpenAI SDK zu erstellen:

  1. Importieren Sie das OpenAI SDK und richten Sie den Client mit den folgenden Feldern ein:

    • base_url— Stellen Sie dem Amazon Bedrock Runtime-Endpunkt das Präfix vor/openai/v1, wie im folgenden Format:

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

    • api_key— Geben Sie einen Amazon Bedrock API-Schlüssel an.

    • default_headers— Wenn Sie Header einbeziehen müssen, können Sie sie als Schlüssel-Wert-Paare in dieses Objekt aufnehmen. Sie können bei einem bestimmten extra_headers API-Aufruf alternativ Header in der angeben.

  2. Verwenden Sie die chat.completions.create() Methode mit dem Client und geben Sie messages im Anfragetext mindestens model und an.

Im folgenden Beispiel wird die Create Chat Completion API in us-west-2 aufgerufen. $AWS_BEARER_TOKEN_BEDROCKErsetzen Sie es durch Ihren tatsächlichen API-Schlüssel.

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

Gehen Sie wie folgt vor, um einen Chat-Abschluss mit einer direkten HTTP-Anfrage zu erstellen:

  1. Geben Sie die URL an, indem Sie dem Amazon Bedrock Runtime-Endpunkt das Präfix /openai/v1/chat/completions voranstellen, wie im folgenden Format:

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

  2. Geben Sie Ihre AWS Anmeldeinformationen oder einen Amazon Bedrock API-Schlüssel in der Authorization Kopfzeile an.

  3. Geben Sie im Hauptteil der Anfrage mindestens model und messages im Anfragetext an.

Im folgenden Beispiel wird Curl verwendet, um die Create Chat Completion API in us-west-2 aufzurufen. Ersetze es $AWS_BEARER_TOKEN_BEDROCK durch deinen tatsächlichen API-Schlüssel:

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

Fügen Sie eine Leitplanke in einen Chat-Abschluss ein

Um Sicherheitsvorkehrungen in Modelleingaben und -antworten einzubeziehen, wenden Sie beim Ausführen des Modellaufrufs eine Leitplanke an, indem Sie die folgenden zusätzlichen Parameter als Felder in den Anforderungstext aufnehmen:

  • extra_headers— Ordnet einem Objekt zu, das die folgenden Felder enthält, die zusätzliche Header in der Anfrage angeben:

    • X-Amzn-Bedrock-GuardrailIdentifier(erforderlich) — Die ID der Leitplanke.

    • X-Amzn-Bedrock-GuardrailVersion(erforderlich) — Die Version der Leitplanke.

    • X-Amzn-Bedrock-Trace(optional) — Ob die Leitplankenverfolgung aktiviert werden soll oder nicht.

  • extra_body— Ordnet einem Objekt zu. In dieses Objekt können Sie das amazon-bedrock-guardrailConfig Feld aufnehmen, das einem Objekt zugeordnet ist, das die folgenden Felder enthält:

Weitere Informationen zu diesen Parametern in Amazon Bedrock Guardrails finden Sie unter. Testen Sie Ihre Leitplanke

Um Beispiele für die Verwendung von Guardrails bei OpenAI Chat-Abschlüssen zu sehen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:

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