Anthropic Claude Messaggi API

Questa sezione fornisce parametri di inferenza ed esempi di codice per l'utilizzo di Anthropic Claude MessaggiAPI.

Anthropic Claude APIPanoramica dei messaggi

Puoi utilizzare i Messaggi API per creare chat bot o applicazioni di assistenza virtuale. APIGestisce gli scambi conversazionali tra un utente e un Anthropic Claude modello (assistente).

Suggerimento

In questo argomento viene illustrato come utilizzare Anthropic Claude messaggi API con le operazioni di inferenza di base (InvokeModelo InvokeModelWithResponseStream). Tuttavia, si consiglia di utilizzare il Converse APIper implementare i messaggi nella tua applicazione. Il Converse APIfornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consulta Effettuare una conversazione con Converse Operazioni API.

Anthropic addestra i modelli di Claude a operare alternando turni di conversazione tra utente e assistente. Quando si crea un nuovo messaggio, si specificano i turni di conversazione precedenti con il parametro messages. Il modello genera quindi il messaggio successivo nella conversazione.

Ogni messaggio di input deve essere un oggetto con un ruolo e un contenuto. È possibile specificare un singolo messaggio relativo al ruolo utente oppure includere più messaggi utente e assistente. Il primo messaggio deve sempre utilizzare il ruolo utente.

Se si utilizza la tecnica di precompilazione della risposta da Claude (compilando l'inizio della risposta di Claude usando un messaggio finale nel ruolo di assistente), Claude risponderai riprendendo da dove avevi interrotto. Con questa tecnica, Claude restituirà comunque una risposta con il ruolo di assistente.

Se il messaggio finale utilizza il ruolo di assistente, il contenuto della risposta riprenderà immediatamente dal contenuto di quel messaggio. Puoi usarlo per vincolare parte della risposta del modello.

Esempio con un singolo messaggio utente:

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

Esempio con turni di conversazione multipli:

[
  {"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?"},
]

Esempio con una risposta parzialmente compilata di Claude:

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

Il contenuto di ogni messaggio di input può essere una singola stringa o una matrice di blocchi di contenuto, in cui ogni blocco ha un tipo specifico. L'uso di una stringa è l'abbreviazione di un array di un blocco di contenuto di tipo «testo». I seguenti messaggi di input sono equivalenti:

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

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

Per informazioni sulla creazione di prompt per Anthropic Claude modelli, vedete Introduzione ai prompt in Anthropic Claude documentazione. Se hai già dei prompt di completamento del testo che desideri migrare ai messaggiAPI, vedi Migrazione da Text Completions.

Richieste di sistema

È inoltre possibile includere un prompt di sistema nella richiesta. Un prompt di sistema consente di fornire contesto e istruzioni per Anthropic Claude, ad esempio specificare un obiettivo o un ruolo particolare. Specificate un prompt di sistema nel system campo, come illustrato nell'esempio seguente.

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

Per ulteriori informazioni, vedete le istruzioni di sistema nel Anthropic documentazione.

Istruzioni multimodali

Un prompt multimodale combina più modalità (immagini e testo) in un unico prompt. Le modalità vengono specificate nel campo di immissione. content L'esempio seguente mostra come puoi chiedere Anthropic Claude per descrivere il contenuto di un'immagine fornita. Per il codice di esempio, consulta Esempi di codice multimodale.

{
    "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?"
                }
            ]
        }
    ]
}

Nota

Le seguenti restrizioni riguardano il content campo:

• Puoi includere fino a 20 immagini. Le dimensioni, l'altezza e la larghezza di ogni immagine non devono superare rispettivamente 3,75 MB, 8.000 px e 8.000 px.

• Puoi includere fino a cinque documenti. Le dimensioni di ogni documento non devono superare i 4,5 MB.

• Puoi includere immagini e documenti solo se lo role èuser.

Ogni immagine che includi in una richiesta viene conteggiata ai fini dell'utilizzo del token. Per ulteriori informazioni, consulta la sezione Costi delle immagini nel Anthropic documentazione.

Utilizzo dello strumento (chiamata di una funzione)

Con Anthropic Claude 3 modelli, è possibile specificare uno strumento che il modello può utilizzare per rispondere a un messaggio. Ad esempio, è possibile specificare uno strumento che riproduca la canzone più popolare su una stazione radio. Se l'utente trasmette il messaggio Qual è la canzone più popolare in ondaWZPZ? , il modello determina che lo strumento specificato può aiutare a rispondere alla domanda. Nella sua risposta, il modello richiede l'esecuzione dello strumento per suo conto. Quindi eseguite lo strumento e passate il risultato dell'utensile al modello, che a sua volta genera una risposta per il messaggio originale. Per ulteriori informazioni, vedete Uso dello strumento (chiamata di funzioni) nel Anthropic Claude documentazione.

Suggerimento

Si consiglia di utilizzare il Converse APIper integrare l'uso degli strumenti nella tua applicazione. Per ulteriori informazioni, consulta Usa uno strumento per completare una risposta al modello Amazon Bedrock.

È possibile specificare gli strumenti che si desidera rendere disponibili a un modello sul tools campo. L'esempio seguente riguarda uno strumento che riceve le canzoni più popolari su una stazione 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"
            ]
        }
    }
]

Quando il modello necessita di uno strumento per generare una risposta a un messaggio, restituisce le informazioni sullo strumento richiesto e l'input dello strumento nel content campo del messaggio. Imposta inoltre il motivo dell'interruzione della risposta atool_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"
}

Nel codice, si chiama lo strumento per conto degli strumenti. Quindi passate lo strumento result (tool_result) in un messaggio utente al modello.

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

Nella sua risposta, il modello utilizza il risultato dello strumento per generare una risposta per il messaggio originale.

{
    "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"
}

Uso del computer (Beta)

L'uso del computer è nuovo Anthropic Claude funzionalità del modello (in versione beta) disponibile solo con Claude 3.5 Sonnet v2. Con l'uso del computer, Claude può aiutarti ad automatizzare le attività tramite GUI azioni di base.

avvertimento

La funzionalità di utilizzo del computer è messa a disposizione dell'utente come «Servizio beta», come definito nei Termini di servizio. AWS È soggetta al Contratto AWS e ai Termini di AWS servizio dell'utente e al modello applicabile. EULA Tieni presente che l'uso del computer API comporta rischi unici che sono diversi dalle API funzionalità standard o dalle interfacce di chat. Questi rischi aumentano quando si utilizza l'uso del computer API per interagire con Internet. Per ridurre al minimo i rischi, prendi in considerazione l'adozione di precauzioni come:

• Utilizza la funzionalità di utilizzo del computer in una macchina virtuale o in un contenitore dedicato con privilegi minimi per prevenire attacchi o incidenti diretti al sistema.

• Per prevenire il furto di informazioni, evita di concedere a Computer Use API l'accesso ad account o dati sensibili.

• Limitazione dell'accesso a Internet da API parte dell'utente del computer ai domini necessari per ridurre l'esposizione a contenuti dannosi.

• Per garantire una supervisione adeguata, tenete sempre aggiornati gli operatori per le attività sensibili (come prendere decisioni che potrebbero avere conseguenze significative nel mondo reale) e per tutto ciò che richiede il consenso affermativo (come accettare i cookie, eseguire transazioni finanziarie o accettare i termini di servizio).

Qualsiasi contenuto che abiliti Claude la visualizzazione o l'accesso possono potenzialmente annullare le istruzioni o la causa Claude commettere errori o eseguire azioni non intenzionali. Prendere le dovute precauzioni, come l'isolamento Claude da superfici sensibili, è essenziale, anche per evitare i rischi legati all'iniezione tempestiva. Prima di abilitare o richiedere le autorizzazioni necessarie per abilitare le funzionalità di utilizzo del computer nei vostri prodotti, informate gli utenti finali di eventuali rischi pertinenti e ottenete il loro consenso, se del caso.

L'uso del computer API offre diversi strumenti predefiniti per l'uso del computer (computer_20241022, bash_20241022 e text_editor_20241022) da utilizzare. Puoi quindi creare un prompt con la tua richiesta, ad esempio «invia un'email a Ben con le note della mia ultima riunione» e uno screenshot (se richiesto). La risposta contiene un elenco di tool_use azioni in JSON formato (ad esempio, scroll_down, left_button_press, screenshot). Il codice esegue le azioni del computer e fornisce Claude con screenshot che mostra gli output (quando richiesto).

Il parametro tools è stato aggiornato per accettare tipi di strumenti polimorfici; è stata aggiunta una nuova tool.type proprietà per distinguerli. typeè facoltativo; se omesso, si presume che lo strumento sia uno strumento personalizzato (in precedenza era l'unico tipo di strumento supportato). Inoltre, è stato aggiunto un nuovo parametroanthropic_beta,, con un valore enum corrispondente:. computer-use-2024-10-22 Solo le richieste effettuate con questo parametro ed enum possono utilizzare i nuovi strumenti di utilizzo del computer. Può essere specificato come segue:"anthropic_beta": ["computer-use-2024-10-22"].

Per ulteriori informazioni, vedere Uso del computer (beta) nel Anthropic documentazione.

Di seguito è riportato un esempio di risposta che presuppone che la richiesta contenga uno screenshot del desktop con l'icona di Firefox.

{
    "id": "msg_123",
    "type": "message",
    "role": "assistant",
    "model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
    "content": [
        {
            "type": "text",
            "text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
        },
        {
            "type": "tool_use",
            "id": "toolu_123",
            "name": "computer",
            "input": {
                "action": "mouse_move",
                "coordinate": [
                    708,
                    736
                ]
            }
        },
        {
            "type": "tool_use",
            "id": "toolu_234",
            "name": "computer",
            "input": {
                "action": "left_click"
            }
        }
    ],
    "stop_reason": "tool_use",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 3391,
        "output_tokens": 132
    }
}

Modelli supportati

Puoi usare i Messaggi API con quanto segue Anthropic Claude modelli.

• Anthropic Claude Instant v1.2

• Anthropic Claude 2 v2

• Anthropic Claude 2 v 2.1

• Anthropic Claude 3 Sonnet

• Anthropic Claude 3.5 Sonnet

• Anthropic Claude 3.5 Sonnet v2

• Anthropic Claude 3 Haiku

• Anthropic Claude 3 Opus

Richiesta e risposta

Il corpo della richiesta viene passato nel body campo di una richiesta a InvokeModelo InvokeModelWithResponseStream. La dimensione massima del payload che puoi inviare in una richiesta è di 20 MB.

Per ulteriori informazioni, consulta https://docs.anthropic.com/claude/ reference/messages_post.

Request

Anthropic Claude ha i seguenti parametri di inferenza per una chiamata di inferenza dei messaggi.

{
    "anthropic_version": "bedrock-2023-05-31", 
    "anthropic_beta": ["computer-use-2024-10-22"] 
    "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": [
        {
                "type": "custom",
                "name": string,
                "description": string,
                "input_schema": json
            
        },
        { 
            "type": "computer_20241022",  
            "name": "computer", 
            "display_height_px": int,
            "display_width_px": int,
            "display_number": 0 int
        },
        { 
            "type": "bash_20241022", 
            "name": "bash"
        },
        { 
            "type": "text_editor_20241022",
            "name": "str_replace_editor"
        }
        
    ],
    "tool_choice": {
        "type" :  string,
        "name" : string,
    },
    

 
    "stop_sequences": [string]
}              

I seguenti sono parametri obbligatori.

• anthropic_version — (Obbligatorio) La versione antropica. Il valore deve essere. bedrock-2023-05-31

• anthropic_beta — (Obbligatorio, se si utilizza il computerAPI) La versione beta antropica da utilizzare. Per utilizzare l'uso del computerAPI, il valore deve essere. computer-use-2024-10-22

• max_tokens — (Obbligatorio) Il numero massimo di token da generare prima dell'interruzione.

  Nota che Anthropic Claude i modelli potrebbero smettere di generare token prima di raggiungere il valore dimax_tokens. Diverso Anthropic Claude i modelli hanno valori massimi diversi per questo parametro. Per ulteriori informazioni, vedete Confronto tra modelli.

• messaggi — (Obbligatorio) I messaggi di input.

  • role — Il ruolo del turno di conversazione. I valori validi sono user e assistant.

  • content — (obbligatorio) Il contenuto del turno di conversazione.

    • tipo — (obbligatorio) Il tipo di contenuto. I valori validi sono image e text.

      Se si specificaimage, è necessario specificare anche l'origine dell'immagine nel seguente formato

      source — (obbligatorio) Il contenuto del turno di conversazione.

      • type — (obbligatorio) Il tipo di codifica dell'immagine. È possibile specificarebase64.

      • media_type — (obbligatorio) Il tipo di immagine. È possibile specificare i seguenti formati di immagine.

        • image/jpeg

        • image/png

        • image/webp

        • image/gif

      • data — (obbligatorio) I byte dell'immagine codificati in base64. La dimensione massima dell'immagine è 3,75 MB. L'altezza e la larghezza massime di un'immagine sono 8000 pixel.

      Se si specificatext, è necessario specificare anche il prompt in. text

I seguenti sono parametri opzionali.

• system — (Facoltativo) Il prompt di sistema per la richiesta.

  Un prompt di sistema è un modo per fornire contesto e istruzioni a Anthropic Claude, ad esempio specificare un obiettivo o un ruolo particolare. Per ulteriori informazioni, consulta le istruzioni di sistema nella Anthropic documentazione.

  Nota

  È possibile utilizzare le istruzioni di sistema con Anthropic Claude versione 2.1 o successiva.

• stop_sequences — (Facoltativo) Sequenze di testo personalizzate che causano l'interruzione della generazione del modello. Anthropic Claude i modelli normalmente si fermano quando hanno naturalmente completato il loro turno, in questo caso il valore del campo di risposta èstop_reason. end_turn Se volete che il modello smetta di generare quando incontra stringhe di testo personalizzate, potete usare il parametro. stop_sequences Se il modello incontra una delle stringhe di testo personalizzate, il valore del campo di stop_reason risposta è stop_sequence e il valore di contiene la sequenza di stop_sequence interruzioni corrispondente.

  Il numero massimo di voci è 8191.

• temperatura — (Facoltativo) La quantità di casualità iniettata nella risposta.

  Predefinita	Minimo	Massimo
  1	0	1

• top_p — (Facoltativo) Usa il campionamento del nucleo.

  Nel campionamento del nucleo, Anthropic Claude calcola la distribuzione cumulativa di tutte le opzioni per ogni token successivo in ordine di probabilità decrescente e la interrompe quando raggiunge una particolare probabilità specificata da. top_p È necessario modificare una delle due temperature o top_p non entrambe.

  Predefinita	Minimo	Massimo
  0,999	0	1

• top_k — (Facoltativo) Campiona solo le prime K opzioni per ogni token successivo.

  Utilizza top_k per rimuovere le risposte a bassa probabilità a coda lunga.

  Predefinita	Minimo	Massimo
  Disabilitato per impostazione predefinita	0	500

• strumenti — (Facoltativo) Definizioni degli strumenti che il modello può utilizzare.

  Nota

  Richiede un Anthropic Claude Modello 3D.

  Se lo includi tools nella richiesta, il modello può restituire blocchi di tool_use contenuto che rappresentano l'utilizzo di tali strumenti da parte del modello. È quindi possibile eseguire tali strumenti utilizzando l'input dello strumento generato dal modello e quindi, facoltativamente, restituire i risultati al modello utilizzando blocchi di tool_result contenuto.

  È possibile passare i seguenti tipi di strumenti:

  Personalizza

  Definizione di uno strumento personalizzato.

  • (opzionale) type: il tipo di utensile. Se definito, utilizzate il valorecustom.

  • name — Il nome dello strumento.

  • descrizione — (facoltativa, ma fortemente consigliata) La descrizione dello strumento.

  • input_schema — Lo JSON schema per lo strumento.

  Computer

  Definizione dello strumento informatico utilizzato con l'uso del computer. API

  • tipo — Il valore deve esserecomputer_20241022.

  • name — Il valore deve esserecomputer.

  • (Obbligatorio) display_height_px — L'altezza dello schermo controllata dal modello, in pixel.

    Predefinita	Minimo	Massimo
    Nessuno	1	Nessun valore massimo

  • (Obbligatorio) display_width_px — La larghezza dello schermo controllata dal modello, in pixel.

    Predefinita	Minimo	Massimo
    Nessuno	1	Nessun valore massimo

  • (Facoltativo) display_number — Il numero di display da controllare (rilevante solo per gli ambienti X11). Se specificato, allo strumento verrà fornito un numero visualizzato nella definizione dello strumento.

    Predefinita	Minimo	Massimo
    Nessuno	0	N

  bash

  Definizione dello strumento bash che si usa con il computer. API

  • (opzionale) type — Il valore deve esserebash_20241022.

  • nome — Il valore deve esserebash. lo strumento.

  editor di testo

  Definizione dello strumento di editor di testo utilizzato con il computerAPI.

  • (opzionale) type: il valore deve esseretext_editor_20241022.

  • nome — Il valore deve esserestr_replace_editor. lo strumento.

• tool_choice — (Facoltativo) Specifica come il modello deve utilizzare gli strumenti forniti. Il modello può utilizzare uno strumento specifico, qualsiasi strumento disponibile o decidere autonomamente.

  Nota

  Richiede un Anthropic Claude Modello 3D.

  • tipo: il tipo di utensile scelto. I valori possibili sono any (utilizzare qualsiasi strumento disponibile), auto (il modello decide) e tool (utilizzare lo strumento specificato).

  • name — (Facoltativo) Il nome dello strumento da utilizzare. Obbligatorio se lo tool si specifica nel type campo.

Response

Il Anthropic Claude il modello restituisce i seguenti campi per una chiamata di inferenza dei messaggi.

{
    "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 — L'identificatore univoco per la risposta. Il formato e la lunghezza dell'ID potrebbero cambiare nel tempo.

• model — L'ID per Anthropic Claude modello che ha effettuato la richiesta.

• stop_reason — Il motivo Anthropic Claude ha smesso di generare la risposta.

  • end_turn — Il modello ha raggiunto un punto di arresto naturale

  • max_tokens — Il testo generato ha superato il valore del campo di max_tokens input o ha superato il numero massimo di token supportati dal modello. '.

  • stop_sequence — Il modello ha generato una delle sequenze di stop specificate nel campo di input. stop_sequences

• stop_sequence — La sequenza di interruzioni che ha terminato la generazione.

• type — Il tipo di risposta. Il valore è sempre message.

• role — Il ruolo conversazionale del messaggio generato. Il valore è sempre assistant.

• content: il contenuto generato dal modello. Restituito come matrice. Esistono due tipi di contenuto, text etool_use.

  • text: una risposta testuale.

    • type — Questo valore ètext. Il tipo di contenuto.

    • testo: il testo del contenuto.

  • tool_use — Una richiesta al modello di utilizzare uno strumento.

    • type — Questo valore è text .Il tipo di contenuto.

    • id — L'ID dello strumento di cui il modello richiede l'utilizzo.

    • input — I parametri di input da passare allo strumento.

• usage — Contenitore per il numero di token forniti nella richiesta e il numero di token generati dal modello nella risposta.

  • input_tokens — Il numero di token di input nella richiesta.

  • output_tokens — Il numero di token generati dal modello nella risposta.

  • stop_sequence — Il modello ha generato una delle sequenze di stop specificate nel campo di input. stop_sequences

Esempi di codice

I seguenti esempi di codice mostrano come utilizzare i messaggi. API

Argomenti

• Esempio di codice Messages

• Esempi di codice multimodale

Esempio di codice Messages

Questo esempio mostra come inviare un messaggio utente a turno singolo e un utente a turno con un messaggio di assistente precompilato a un Anthropic Claude 3 Sonnet modello.

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

Esempi di codice multimodale

Gli esempi seguenti mostrano come passare un'immagine e richiedere il testo in un messaggio multimodale a un Anthropic Claude 3 Sonnet modello.

Argomenti

• Richiesta multimodale con InvokeModel

• Richiesta multimodale in streaming con InvokeModelWithResponseStream

Richiesta multimodale con InvokeModel

L'esempio seguente mostra come inviare un prompt multimodale a Anthropic Claude 3 Sonnet con. 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()

Richiesta multimodale in streaming con InvokeModelWithResponseStream

L'esempio seguente mostra come trasmettere in streaming la risposta da un prompt multimodale inviato a Anthropic Claude 3 Sonnet InvokeModelWithResponseStreamcon.

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