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

AnthropicClaudePesan API

Bagian ini menyediakan parameter inferensi dan contoh kode untuk menggunakan Anthropic Claude Messages API.

AnthropicClaudeIkhtisar pesan API

Anda dapat menggunakan Messages API untuk membuat bot obrolan atau aplikasi asisten virtual. API mengelola pertukaran percakapan antara pengguna dan Anthropic Claude model (asisten).

Anthropicmelatih model Claude untuk beroperasi pada giliran percakapan pengguna dan asisten yang bergantian. Saat membuat pesan baru, Anda menentukan giliran percakapan sebelumnya dengan parameter pesan. Model kemudian menghasilkan Pesan berikutnya dalam percakapan.

Setiap pesan input harus berupa objek dengan peran dan konten. Anda dapat menentukan satu pesan peran pengguna, atau Anda dapat menyertakan beberapa pesan pengguna dan asisten. Pesan pertama harus selalu menggunakan peran pengguna.

Jika Anda menggunakan teknik pengisian awal respons dari Claude (mengisi awal respons Claude dengan menggunakan peran asisten akhir Pesan), Claude akan merespons dengan mengambil dari tempat Anda tinggalkan. Dengan teknik ini, masih Claude akan mengembalikan respons dengan peran asisten.

Jika pesan terakhir menggunakan peran asisten, konten respons akan langsung dilanjutkan dari konten dalam pesan tersebut. Anda dapat menggunakan ini untuk membatasi bagian dari respons model.

Contoh dengan pesan pengguna tunggal:

[{"role": "user", "content": "Hello, Claude"}]

Contoh dengan beberapa putaran percakapan:

[
  {"role": "user", "content": "Hello there."},
  {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
  {"role": "user", "content": "Can you explain LLMs in plain English?"},
]

Contoh dengan respons yang diisi sebagian dari Claude:

[
  {"role": "user", "content": "Please describe yourself using only JSON"},
  {"role": "assistant", "content": "Here is my JSON description:\n{"},
]

Setiap konten pesan input dapat berupa string tunggal atau array blok konten, di mana setiap blok memiliki tipe tertentu. Menggunakan string adalah singkatan untuk array dari satu blok konten tipe “teks”. Pesan masukan berikut setara:

{"role": "user", "content": "Hello, Claude"}

{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}

Untuk informasi tentang membuat prompt untuk Anthropic Claude model, lihat Pengantar petunjuk dalam dokumentasi. Anthropic Claude Jika Anda memiliki prompt Penyelesaian Teks yang ingin dimigrasikan ke API pesan, lihat Memigrasi dari Penyelesaian Teks.

Permintaan sistem

Anda juga dapat menyertakan prompt sistem dalam permintaan. Prompt sistem memungkinkan Anda memberikan konteks dan instruksi AnthropicClaude, seperti menentukan tujuan atau peran tertentu. Tentukan prompt sistem di system lapangan, seperti yang ditunjukkan pada contoh berikut.

"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
                harmless, and honest. Your goal is to provide informative and substantive responses
                to queries while avoiding potential harms."

Untuk informasi selengkapnya, lihat Permintaan sistem dalam Anthropic dokumentasi.

Permintaan multimodal

Prompt multimodal menggabungkan beberapa modalitas (gambar dan teks) dalam satu prompt. Anda menentukan modalitas di bidang content input. Contoh berikut menunjukkan bagaimana Anda bisa meminta Anthropic Claude untuk mendeskripsikan konten gambar yang disediakan. Untuk kode sampel, lihat Contoh kode multimodal.

{
    "anthropic_version": "bedrock-2023-05-31", 
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": "iVBORw..."
                    }
                },
                {
                    "type": "text",
                    "text": "What's in these images?"
                }
            ]
        }
    ]
}

Anda dapat menyediakan hingga 20 gambar ke model. Anda tidak dapat menempatkan gambar dalam peran asisten.

Setiap gambar yang Anda sertakan dalam permintaan dihitung terhadap penggunaan token Anda. Untuk informasi selengkapnya, lihat Biaya gambar dalam Anthropic dokumentasi.

Model yang didukung

Anda dapat menggunakan Messages API dengan Anthropic Claude model berikut.

Permintaan dan Tanggapan

Badan permintaan diteruskan di body bidang permintaan ke InvokeModelatau InvokeModelWithResponseStream. Ukuran maksimum muatan yang dapat Anda kirim dalam permintaan adalah 20MB.

Untuk informasi lebih lanjut, lihat https://docs.anthropic.com/claude/reference/messages_post.

Request

AnthropicClaudememiliki parameter inferensi berikut untuk panggilan inferensi pesan.

{
    "anthropic_version": "bedrock-2023-05-31",    
    "max_tokens": int,
    "system": string,    
    "messages": [
        {
            "role": string,
            "content": [
                { "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
                { "type": "text", "text": "content text" }
      ]
        }
    ],
    "temperature": float,
    "top_p": float,
    "top_k": int,
    "stop_sequences": [string]
}              

Berikut ini adalah parameter yang diperlukan.

• anthropic_version — (Wajib) Versi antropik. Nilainya harusbedrock-2023-05-31.

• max_tokens — (Wajib) Jumlah maksimum token yang akan dihasilkan sebelum berhenti.

  Perhatikan bahwa Anthropic Claude model mungkin berhenti menghasilkan token sebelum mencapai nilaimax_tokens. AnthropicClaudeModel yang berbeda memiliki nilai maksimum yang berbeda untuk parameter ini. Untuk informasi lebih lanjut, lihat Perbandingan model.

• pesan — (Wajib) Pesan masukan.

  • peran — Peran percakapan berubah. Nilai yang valid adalah user dan assistant.

  • konten — (wajib) Isi percakapan berubah.

    • type — (wajib) Jenis konten. Nilai yang valid adalah image dan text.

      Jika Anda menentukanimage, Anda juga harus menentukan sumber gambar dalam format berikut

      sumber — (wajib) Isi percakapan berubah.

      • type — (required) Jenis pengkodean untuk gambar. Anda dapat menentukanbase64.

      • media_type — (wajib) Jenis gambar. Anda dapat menentukan format gambar berikut.

        • image/jpeg

        • image/png

        • image/webp

        • image/gif

      • data - (wajib) Byte gambar yang dikodekan base64 untuk gambar. Ukuran gambar maksimum adalah 3.75MB. Tinggi dan lebar maksimum gambar adalah 8000 piksel.

      Jika Anda menentukantext, Anda juga harus menentukan prompt ditext.

Berikut ini adalah parameter opsional.

• sistem — (Opsional) Prompt sistem untuk permintaan.

  Prompt sistem adalah cara untuk memberikan konteks dan instruksi AnthropicClaude, seperti menentukan tujuan atau peran tertentu. Untuk informasi selengkapnya, lihat Cara menggunakan prompt sistem dalam Anthropic dokumentasi.

  catatan

  Anda dapat menggunakan prompt sistem dengan Anthropic Claude versi 2.1 atau lebih tinggi.

• stop_sequences — (Opsional) Urutan teks khusus yang menyebabkan model berhenti menghasilkan. AnthropicClaudemodel biasanya berhenti ketika mereka secara alami menyelesaikan giliran mereka, dalam hal ini nilai bidang stop_reason respons adalahend_turn. Jika Anda ingin model berhenti menghasilkan ketika menemukan string teks khusus, Anda dapat menggunakan parameter. stop_sequences Jika model menemukan salah satu string teks kustom, nilai bidang stop_reason respons adalah stop_sequence dan nilai stop_sequence berisi urutan berhenti yang cocok.

  Jumlah entri maksimum adalah 8191.

• suhu — (Opsional) Jumlah keacakan yang disuntikkan ke dalam respons.

  Default	Minimum	Maksimum
  1	0	1

• top_p — (Opsional) Gunakan pengambilan sampel nukleus.

  Dalam pengambilan sampel nukleus, Anthropic Claude menghitung distribusi kumulatif atas semua opsi untuk setiap token berikutnya dalam urutan probabilitas yang menurun dan memotongnya setelah mencapai probabilitas tertentu yang ditentukan oleh. top_p Anda harus mengubah salah satu temperature atautop_p, tetapi tidak keduanya.

  Default	Minimum	Maksimum
  0,999	0	1

Berikut ini adalah parameter opsional.

• top_k — (Opsional) Hanya sampel dari opsi K teratas untuk setiap token berikutnya.

  Gunakan top_k untuk menghapus respons probabilitas rendah ekor panjang.

  Default	Minimum	Maksimum
  Dinonaktifkan secara default	0	500

Response

AnthropicClaudeModel mengembalikan bidang berikut untuk panggilan inferensi pesan.

{
    "id": string,
    "model": string,
    "type" : "message",
    "role" : "assistant",
    "content": [
        {
            "type": "text",
            "text": string
        }
    ],
    "stop_reason": string,
    "stop_sequence": string,
    "usage": {
        "input_tokens": integer,
        "output_tokens": integer
    }
    
}

• id — Pengidentifikasi unik untuk respons. Format dan panjang ID mungkin berubah seiring waktu.

• model — ID untuk Anthropic Claude model yang membuat permintaan.

• stop_reason — Alasan mengapa Anthropic Claude berhenti menghasilkan respons.

  • end_turn — Model mencapai titik berhenti alami

  • max_tokens — Teks yang dihasilkan melebihi nilai bidang max_tokens input atau melebihi jumlah maksimum token yang didukung model. '.

  • stop_sequence - Model menghasilkan salah satu urutan berhenti yang Anda tentukan di bidang input. stop_sequences

• Jenis — Jenis respon. Nilainya selalu message.

• peran — Peran percakapan dari pesan yang dihasilkan. Nilainya selalu assistant.

• konten — Konten yang dihasilkan oleh model. Dikembalikan sebagai array.

  • type — Jenis konten. Satu-satunya nilai yang di-support saat ini adalah text.

  • teks — Teks konten.

• penggunaan — Penampung untuk jumlah token yang Anda berikan dalam permintaan dan token nomor dari model yang dihasilkan dalam respons.

  • input_tokens — Jumlah token masukan dalam permintaan.

  • output_tokens — Jumlah token dari model yang dihasilkan dalam respons.

  • stop_sequence - Model menghasilkan salah satu urutan berhenti yang Anda tentukan di bidang input. stop_sequences

Contoh kode

Contoh kode berikut menunjukkan cara menggunakan API pesan.

Contoh kode pesan

Contoh ini menunjukkan cara mengirim pesan pengguna giliran tunggal dan giliran pengguna dengan pesan asisten yang telah diisi sebelumnya ke Anthropic Claude 3 Sonnet model.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):

    body=json.dumps(
        {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": max_tokens,
            "system": system_prompt,
            "messages": messages
        }  
    )  

    
    response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
    response_body = json.loads(response.get('body').read())
   
    return response_body


def main():
    """
    Entrypoint for Anthropic Claude message example.
    """

    try:

        bedrock_runtime = boto3.client(service_name='bedrock-runtime')

        model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
        system_prompt = "Please respond only with emoji."
        max_tokens = 1000

        # Prompt with user turn only.
        user_message =  {"role": "user", "content": "Hello World"}
        messages = [user_message]

        response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
        print("User turn only.")
        print(json.dumps(response, indent=4))

        # Prompt with both user turn and prefilled assistant response.
        #Anthropic Claude continues by using the prefilled assistant text.
        assistant_message =  {"role": "assistant", "content": "<emoji>"}
        messages = [user_message, assistant_message]
        response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
        print("User turn and prefilled assistant response.")
        print(json.dumps(response, indent=4))

    except ClientError as err:
        message=err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
            format(message))

if __name__ == "__main__":
    main()

Contoh kode multimodal

Contoh berikut menunjukkan cara meneruskan gambar dan teks prompt dalam pesan multimodal ke Anthropic Claude 3 Sonnet model.

Prompt multimodal dengan InvokeModel

Contoh berikut menunjukkan cara mengirim prompt multimodal ke Anthropic Claude 3 Sonnet with InvokeModel.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""

import json
import logging
import base64
import boto3

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
    """
    Invokes a model with a multimodal prompt.
    Args:
        bedrock_runtime: The Amazon Bedrock boto3 client.
        model_id (str): The model ID to use.
        messages (JSON) : The messages to send to the model.
        max_tokens (int) : The maximum  number of tokens to generate.
    Returns:
        None.
    """



    body = json.dumps(
        {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": max_tokens,
             "messages": messages
        }
    )

    response = bedrock_runtime.invoke_model(
        body=body, modelId=model_id)
    response_body = json.loads(response.get('body').read())

    return response_body


def main():
    """
    Entrypoint for Anthropic Claude multimodal prompt example.
    """

    try:

        bedrock_runtime = boto3.client(service_name='bedrock-runtime')

        model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
        max_tokens = 1000
        input_image = "/path/to/image"
        input_text = "What's in this image?"

 
        # Read reference image from file and encode as base64 strings.
        with open(input_image, "rb") as image_file:
            content_image = base64.b64encode(image_file.read()).decode('utf8')

        message = {"role": "user",
             "content": [
                {"type": "image", "source": {"type": "base64",
                    "media_type": "image/jpeg", "data": content_image}},
                {"type": "text", "text": input_text}
                ]}

    
        messages = [message]

        response = run_multi_modal_prompt(
            bedrock_runtime, model_id, messages, max_tokens)
        print(json.dumps(response, indent=4))

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))


if __name__ == "__main__":
    main()

Streaming prompt multimodal dengan InvokeModelWithResponseStream

Contoh berikut menunjukkan cara mengalirkan respons dari prompt multimodal yang dikirim ke Anthropic Claude 3 Sonnet with InvokeModelWithResponseStream.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a 
multimodal request.
"""

import json
import base64
import logging
import boto3

from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
    """
    Streams the response from a multimodal prompt.
    Args:
        bedrock_runtime: The Amazon Bedrock boto3 client.
        model_id (str): The model ID to use.
        input_text (str) : The prompt text
        image (str) : The path to  an image that you want in the prompt.
        max_tokens (int) : The maximum  number of tokens to generate.
    Returns:
        None.
    """

    with open(image, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read())

    body = json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": max_tokens,
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": input_text},
                    {"type": "image", "source": {"type": "base64",
                                                 "media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
                ]
            }
        ]
    })

    response = bedrock_runtime.invoke_model_with_response_stream(
        body=body, modelId=model_id)

    for event in response.get("body"):
        chunk = json.loads(event["chunk"]["bytes"])

        if chunk['type'] == 'message_delta':
            print(f"\nStop reason: {chunk['delta']['stop_reason']}")
            print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
            print(f"Output tokens: {chunk['usage']['output_tokens']}")

        if chunk['type'] == 'content_block_delta':
            if chunk['delta']['type'] == 'text_delta':
                print(chunk['delta']['text'], end="")


def main():
    """
    Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
    """

    model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
    input_text = "What can you tell me about this image?"
    image = "/path/to/image"
    max_tokens = 100

    try:

        bedrock_runtime = boto3.client('bedrock-runtime')

        stream_multi_modal_prompt(
            bedrock_runtime, model_id, input_text, image, max_tokens)

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))


if __name__ == "__main__":
    main()