Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Memanggil model dengan OpenAI Chat Completions API
<a name="inference-chat-completions"></a>

Anda dapat menjalankan inferensi model menggunakan [OpenAICreate chat completion API](https://platform.openai.com/docs/api-reference/chat/create) dengan model Amazon Bedrock.

Anda dapat memanggil Create chat completion API dengan cara berikut:
+ Buat permintaan HTTP dengan endpoint Amazon Bedrock Runtime.
+ Gunakan permintaan OpenAI SDK dengan titik akhir Amazon Bedrock Runtime.

Pilih topik untuk mempelajari lebih lanjut:

**Topics**
+ [Model dan Wilayah yang didukung untuk API Penyelesaian OpenAI Obrolan](#inference-chat-completions-supported)
+ [Prasyarat untuk menggunakan API Penyelesaian Obrolan](#inference-chat-completions-prereq)
+ [Buat penyelesaian obrolan](#inference-chat-completions-create)
+ [Sertakan pagar pembatas dalam penyelesaian obrolan](#inference-chat-completions-guardrails)

## Model dan Wilayah yang didukung untuk API Penyelesaian OpenAI Obrolan
<a name="inference-chat-completions-supported"></a>

Anda dapat menggunakan API penyelesaian obrolan Buat dengan semua OpenAI model yang didukung di Amazon Bedrock dan di AWS Wilayah yang mendukung model ini. Untuk informasi selengkapnya tentang model dan wilayah yang didukung, lihat[Model pondasi yang didukung di Amazon Bedrock](models-supported.md).

## Prasyarat untuk menggunakan API Penyelesaian Obrolan
<a name="inference-chat-completions-prereq"></a>

Untuk melihat prasyarat untuk menggunakan API Penyelesaian Obrolan, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:

------
#### [ OpenAI SDK ]
+ **Otentikasi** — OpenAI SDK hanya mendukung otentikasi dengan kunci Amazon Bedrock API. Buat kunci Amazon Bedrock API untuk mengautentikasi permintaan Anda. Untuk mempelajari kunci Amazon Bedrock API dan cara membuatnya, lihat bagian Kunci API di chapter Build.
+ **Endpoint** — Temukan titik akhir yang sesuai dengan AWS Wilayah yang akan digunakan di titik akhir dan kuota [Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Jika Anda menggunakan AWS SDK, Anda mungkin hanya perlu menentukan kode wilayah dan bukan seluruh titik akhir saat menyiapkan klien.
+ **Menginstal OpenAI SDK** — Untuk informasi selengkapnya, lihat [Pustaka](https://platform.openai.com/docs/libraries) dalam dokumentasi. OpenAI

------
#### [ HTTP request ]
+ **Otentikasi** - Anda dapat mengautentikasi dengan AWS kredensi Anda atau dengan kunci Amazon Bedrock API.

  Siapkan AWS kredensi Anda atau buat kunci Amazon Bedrock API untuk mengautentikasi permintaan Anda.
  + Untuk mempelajari cara menyiapkan AWS kredensil Anda, lihat [Akses terprogram dengan AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) kredensial keamanan.
  + Untuk mempelajari kunci Amazon Bedrock API dan cara membuatnya, lihat bagian Kunci API di chapter Build.
+ **Endpoint** — Temukan titik akhir yang sesuai dengan AWS Wilayah yang akan digunakan di titik akhir dan kuota [Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Jika Anda menggunakan AWS SDK, Anda mungkin hanya perlu menentukan kode wilayah dan bukan seluruh titik akhir saat menyiapkan klien.

------

## Buat penyelesaian obrolan
<a name="inference-chat-completions-create"></a>

Lihat sumber daya berikut dalam OpenAI dokumentasi untuk detail tentang Create chat completion API:
+ [Minta parameter tubuh](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parameter tubuh respons](https://platform.openai.com/docs/api-reference/chat/object)

**catatan**  
Amazon Bedrock saat ini tidak mendukung operasi API penyelesaian OpenAI Obrolan lainnya.

Untuk mempelajari cara menggunakan OpenAI Create chat completion API, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:

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

Untuk membuat penyelesaian obrolan dengan OpenAI SDK, lakukan hal berikut:

1. Impor OpenAI SDK dan atur klien dengan bidang berikut:
   + `base_url`— Awali titik akhir Amazon Bedrock Runtime ke`/openai/v1`, seperti dalam format berikut:

     ```
     https://${bedrock-runtime-endpoint}/openai/v1
     ```
   + `api_key`— Tentukan kunci API Amazon Bedrock.
   + `default_headers`— Jika Anda perlu menyertakan header apa pun, Anda dapat memasukkannya sebagai pasangan kunci-nilai dalam objek ini. Anda juga dapat menentukan header di `extra_headers` saat melakukan panggilan API tertentu.

1. Gunakan `chat.completions.create()` metode dengan klien dan tentukan secara minimal `model` dan `messages` di badan permintaan.

Contoh berikut memanggil Create chat completion API di`us-west-2`. Ganti *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* dengan kunci API Anda yang sebenarnya.

```
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 ]

Untuk membuat penyelesaian obrolan dengan permintaan HTTTP langsung, lakukan hal berikut:

1. Tentukan URL dengan mengawali titik akhir Amazon Bedrock Runtime ke`/openai/v1/chat/completions`, seperti dalam format berikut:

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

1. Tentukan AWS kredensil Anda atau kunci Amazon Bedrock API di header. `Authorization`

1. Di badan permintaan, tentukan setidaknya `model` dan `messages` di badan permintaan.

Contoh berikut menggunakan curl untuk memanggil Create chat completion API di`us-west-2`. Ganti *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* dengan kunci API Anda yang sebenarnya:

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

------

## Sertakan pagar pembatas dalam penyelesaian obrolan
<a name="inference-chat-completions-guardrails"></a>

Untuk menyertakan perlindungan dalam input dan respons model, terapkan [pagar pembatas](guardrails.md) saat menjalankan pemanggilan model dengan menyertakan [parameter tambahan](https://github.com/openai/openai-python#undocumented-request-params) berikut sebagai bidang di badan permintaan:
+ `extra_headers`— Peta ke objek yang berisi bidang berikut, yang menentukan header tambahan dalam permintaan:
  + `X-Amzn-Bedrock-GuardrailIdentifier`(wajib) — ID pagar pembatas.
  + `X-Amzn-Bedrock-GuardrailVersion`(wajib) — Versi pagar pembatas.
  + `X-Amzn-Bedrock-Trace`(opsional) - Apakah akan mengaktifkan jejak pagar pembatas atau tidak.
+ `extra_body`— Peta ke suatu objek. Dalam objek itu, Anda dapat menyertakan `amazon-bedrock-guardrailConfig` bidang, yang memetakan ke objek yang berisi bidang berikut:
  + `tagSuffix`(opsional) - Sertakan bidang ini untuk [penandaan input](guardrails-tagging.md).

Untuk informasi selengkapnya tentang parameter ini di Amazon Bedrock Guardrails, lihat. [Uji pagar pembatas Anda](guardrails-test.md)

Untuk melihat contoh penggunaan pagar pembatas dengan penyelesaian OpenAI obrolan, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:

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

------