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

Anthropic Claude Pesan API

Bagian ini memberikan parameter inferensi dan contoh kode untuk menggunakan Anthropic Claude PesanAPI.

Anthropic Claude APIIkhtisar pesan

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

Anthropic melatih 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 masukan 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 prefilling respon dari Claude (mengisi awal tanggapan Claude dengan menggunakan peran asisten akhir Pesan), Claude akan merespons dengan mengambil dari tempat Anda tinggalkan. Dengan teknik ini, Claude masih 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 di Anthropic Claude dokumentasi. Jika Anda memiliki perintah Penyelesaian Teks yang ingin dimigrasikan ke pesanAPI, lihat Memigrasi dari Penyelesaian Teks.

Permintaan sistem

Anda juga dapat menyertakan prompt sistem dalam permintaan. Prompt sistem memungkinkan Anda memberikan konteks dan instruksi Anthropic Claude, 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 di 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 bertanya Anthropic Claude untuk menggambarkan isi dari 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?"
                }
            ]
        }
    ]
}

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

Penggunaan alat (panggilan fungsi)

Dengan Anthropic Claude 3 model, Anda dapat menentukan alat yang dapat digunakan model untuk menjawab pesan. Misalnya, Anda dapat menentukan alat yang mendapatkan lagu paling populer di stasiun radio. Jika pengguna meneruskan pesan Lagu apa yang paling populerWZPZ? , model menentukan bahwa alat yang Anda tentukan dapat membantu menjawab pertanyaan. Dalam tanggapannya, model meminta Anda menjalankan alat atas namanya. Anda kemudian menjalankan alat dan meneruskan hasil alat ke model, yang kemudian menghasilkan respons untuk pesan asli. Untuk informasi selengkapnya, lihat Penggunaan alat (pemanggilan fungsi) di Anthropic Claude dokumentasi.

Anda menentukan alat yang ingin Anda sediakan untuk model di tools bidang. Contoh berikut adalah untuk alat yang mendapatkan lagu paling populer di stasiun radio.

[
    {
        "name": "top_song",
        "description": "Get the most popular song played on a radio station.",
        "input_schema": {
            "type": "object",
            "properties": {
                "sign": {
                    "type": "string",
                    "description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
                }
            },
            "required": [
                "sign"
            ]
        }
    }
]

Ketika model membutuhkan alat untuk menghasilkan respons terhadap pesan, ia mengembalikan informasi tentang alat yang diminta, dan input ke alat, di content bidang pesan. Ini juga menetapkan alasan berhenti untuk menanggapitool_use.

{
    "id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
    "type": "message",
    "role": "assistant",
    "model": "claude-3-sonnet-20240229",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 375,
        "output_tokens": 36
    },
    "content": [
        {
            "type": "tool_use",
            "id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
            "name": "top_song",
            "input": {
                "sign": "WZPZ"
            }
        }
    ],
    "stop_reason": "tool_use"
}

Dalam kode Anda, Anda memanggil alat atas nama alat. Anda kemudian meneruskan hasil alat (tool_result) dalam pesan pengguna ke model.

{
    "role": "user",
    "content": [
        {
            "type": "tool_result",
            "tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
            "content": "Elemental Hotel"
        }
    ]
}

Dalam tanggapannya, model menggunakan hasil alat untuk menghasilkan respons untuk pesan asli.

{
    "id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
    "type": "message",
    "role": "assistant",
    "model": "claude-3-sonnet-20240229",
    "content": [
        {
            "type": "text",
            "text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
        }
    ],
    "stop_reason": "end_turn"
}

Model yang didukung

Anda dapat menggunakan Pesan API dengan berikut Anthropic Claude model.

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 selengkapnya, lihat https://docs.anthropic.com/claude/referensi/messages_post.

Request

Anthropic Claude memiliki 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,
    "tools": [
        {
                "name": string,
                "description": string,
                "input_schema": json
            
        }
    ],
    "tool_choice": {
        "type" :  string,
        "name" : string,
    },
    "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. Berbeda Anthropic Claude model 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 Anthropic Claude, seperti menentukan tujuan atau peran tertentu. Untuk informasi selengkapnya, lihat Permintaan sistem di 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. Anthropic Claude model 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

• 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

• alat — (Opsional) Definisi alat yang dapat digunakan model.

  catatan

  Membutuhkan Anthropic Claude 3 model.

  Jika Anda menyertakan tools dalam permintaan Anda, model dapat mengembalikan blok tool_use konten yang mewakili penggunaan alat tersebut oleh model. Anda kemudian dapat menjalankan alat tersebut menggunakan input alat yang dihasilkan oleh model dan kemudian secara opsional mengembalikan hasil kembali ke model menggunakan blok tool_result konten.

  • nama — Nama alat.

  • deskripsi — (opsional, tetapi sangat disarankan) Deskripsi alat.

  • input_schema — JSON Skema untuk alat.

• tool_choice — (Opsional) Mengkhususkan bagaimana model harus menggunakan alat yang disediakan. Model dapat menggunakan alat tertentu, alat apa pun yang tersedia, atau memutuskan dengan sendirinya.

  catatan

  Membutuhkan Anthropic Claude 3 model.

  • Jenis — Jenis pilihan alat. Nilai yang mungkin adalah any (gunakan alat apa pun yang tersedia), auto (model memutuskan), dan tool (gunakan alat yang ditentukan).

  • nama — (Opsional) Nama alat yang akan digunakan. Diperlukan jika Anda menentukan tool di type bidang.

Response

Bagian Anthropic Claude model mengembalikan bidang berikut untuk panggilan inferensi pesan.

{
    "id": string,
    "model": string,
    "type" : "message",
    "role" : "assistant",
    "content": [
        {
            "type": string,
            "text": string
        }
    ],
    "stop_reason": string,
    "stop_sequence": string,
    "tool_use" : {
        "type": string,
        "id" : string,
        "input" : json
    },        
    "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

• stop_sequence — Urutan berhenti yang mengakhiri generasi.

• 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. Ada dua jenis konten, text dantool_use.

  • teks — Sebuah respon teks.

    • type — Nilai ini adalahtext. Jenis kontennya.

    • teks — Teks konten.

  • tool_use — Permintaan dari model untuk menggunakan alat.

    • type — Nilai ini text adalah. Jenis konten.

    • id — ID untuk alat yang diminta oleh model.

    • input — Parameter input untuk diteruskan ke alat.

• 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 pesanAPI.

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 dengan 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 dengan 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()