Modelli e caratteristiche del modello supportati Utilizzo dell'API Converse Esempi di API Converse

Usa l'API Converse

Puoi utilizzare l'API Amazon Bedrock Converse per creare applicazioni conversazionali che inviano e ricevono messaggi da e verso un modello Amazon Bedrock. Ad esempio, puoi creare un chat bot che mantiene una conversazione a più turni e utilizza una personalizzazione del personaggio o del tono adatta alle tue esigenze, ad esempio un utile assistente di supporto tecnico.

Per utilizzare l'API Converse, si utilizzano le operazioni Converse o ConverseStream(per lo streaming delle risposte) per inviare messaggi a un modello. È possibile utilizzare le operazioni di inferenza esistenti (InvokeModelo InvokeModelWithResponseStream) per le applicazioni di conversazione. Tuttavia, consigliamo di utilizzare l'API Converse in quanto fornisce un'API coerente, che funziona con tutti i modelli Amazon Bedrock che supportano i messaggi. Ciò significa che puoi scrivere il codice una sola volta e utilizzarlo con modelli diversi. Se un modello ha parametri di inferenza unici, l'API Converse ti consente anche di passare quei parametri unici in una struttura specifica del modello.

Puoi utilizzare l'API Converse per implementare l'uso degli strumenti e i guardrail nelle tue applicazioni.

Nota

Oltre ai Mistral AI modelli Meta open source, l'API Converse incorpora i tuoi input in un modello di prompt specifico del modello che abilita le conversazioni.

Argomenti

Modelli e caratteristiche del modello supportati
Utilizzo dell'API Converse
Esempi di API Converse

Modelli e caratteristiche del modello supportati

L'API Converse supporta i seguenti modelli e funzionalità di Amazon Bedrock. L'API Converse non supporta alcun modello di incorporamento (comeTitan Embeddings G1 - Text) o modello di generazione di immagini (come). Stability AI

Modello	conversare	ConverseStream	Richieste di sistema	Chat relativa ai documenti	Vista	Uso dello strumento	Utilizzo dello strumento di streaming	Guardrail
AI21 Jamba-Instruct	Sì	No	Sì	No	No	No	No	No
AI21 LabsJurassic-2(Testo)	Limitato. Nessun supporto via chat.	No	No	No	No	No	No	Sì
TitanModelli Amazon	Sì	Sì	No	Sì (eccettoTitan Text Premier)	No	No	No	Sì
AnthropicClaude2 e versioni precedenti	Sì	Sì	Sì	Sì	No	No	No	Sì
AnthropicClaude3	Sì	Sì	Sì	Sì	Sì	Sì	Sì	Sì
AnthropicClaude3.5	Sì	Sì	Sì	No	Sì	Sì	Sì	Sì
Cohere Command	Limitato. Nessun supporto via chat.	Limitato. Nessun supporto via chat.	No	Sì	No	No	No	Sì
Cohere Command Light	Limitato. Nessun supporto via chat.	Limitato. Nessun supporto via chat.	No	No	No	No	No	Sì
Cohere e Command R Command R+	Sì	Sì	Sì	Sì	No	Sì	No	No
Meta e Llama 2 Llama 3	Sì	Sì	Sì	Sì	No	No	No	Sì
Mistral AI Instruct	Sì	Sì	No	Sì	No	No	No	Sì
Mistral Large	Sì	Sì	Sì	Sì	No	Sì	No	Sì
Mistral Small	Sì	Sì	Sì	No	No	Sì	No	Sì

Nota

CohereCommand(Testo) e AI21 Labs Jurassic-2 (Testo) non supportano la chat con l'API Converse. I modelli possono gestire solo un messaggio utente alla volta e non possono mantenere la cronologia di una conversazione. Viene visualizzato un errore se si tenta di trasmettere più di un messaggio.

Utilizzo dell'API Converse

Per utilizzare l'API Converse, chiami le ConverseStream operazioni Converse o per inviare messaggi a un modello. Per chiamareConverse, è necessaria l'autorizzazione per l'bedrock:InvokeModeloperazione. Per chiamareConverseStream, è necessaria l'autorizzazione per l'bedrock:InvokeModelWithResponseStreamoperazione.

Richiesta

È possibile specificare il modello che si desidera utilizzare impostando il modelId campo. Per un elenco degli ID di modello supportati da Amazon Bedrock, consultaID dei modelli Amazon Bedrock.

Una conversazione è una serie di messaggi tra l'utente e il modello. Si avvia una conversazione inviando un messaggio come utente (ruolo utente) al modello. Il modello, che funge da assistente (ruolo di assistente), genera quindi una risposta che restituisce in un messaggio. Se lo desideri, puoi continuare la conversazione inviando altri messaggi sul ruolo utente al modello. Per mantenere il contesto della conversazione, assicuratevi di includere tutti i messaggi relativi al ruolo di assistente che ricevete dal modello nelle richieste successive. Per il codice di esempio, consulta Esempi di API Converse.

I messaggi che desideri passare a un modello vengono forniti messages sul campo, che viene mappato a una matrice di oggetti Message. Ogni messaggio contiene il contenuto del messaggio e il ruolo che il messaggio svolge nella conversazione.

Nota

Amazon Bedrock non memorizza testo, immagini o documenti che fornisci come contenuto. I dati vengono utilizzati solo per generare la risposta.

Il contenuto del messaggio viene memorizzato nel content campo, che corrisponde a una serie di ContentBlockoggetti. All'interno di ciascuno ContentBlock, puoi specificare uno dei seguenti campi (per vedere quali modelli supportano quali modalità, vediModelli e caratteristiche del modello supportati):

text

Il text campo viene mappato su una stringa che specifica il prompt. Il text campo viene interpretato insieme ad altri campi specificati nello stesso. ContentBlock

Quanto segue mostra un oggetto Message con una content matrice contenente solo un testo ContentBlock:


{
    "role": "user | assistant",
    "content": [
        {
            "text": "string"
        }
    ]
}

image

Il image campo è mappato su un ImageBlock. Passa i byte non elaborati, codificati in base64, per un'immagine nel campo. bytes Se si utilizza un AWS SDK, non è necessario codificare i byte in base64.

Se si esclude il text campo, il modello descriverà l'immagine.

Quanto segue mostra un oggetto Message con un content array contenente solo un'immagine: ContentBlock


{
    "role": "user",
    "content": [
        {
            "image": {
                "format": "png | jpeg | gif | webp",
                "source": {
                    "bytes": "image in bytes"
                }
            }
        }
    ]
}

document

Il document campo è mappato su un. DocumentBlock Se includi unDocumentBlock, verifica che la tua richiesta sia conforme alle seguenti restrizioni:

Nel content campo dell'oggetto Message, devi includere anche un text campo con un prompt relativo al documento.
Passate i byte non elaborati, codificati in base64, per il documento nel campo. bytes Se utilizzate un AWS SDK, non è necessario codificare i byte del documento in base64.
Il name campo può contenere solo i seguenti caratteri:
- Caratteri alfanumerici
- Caratteri di spaziatura (non più di uno di seguito)
- Trattini
- Parentesi
- Parentesi quadre
Nota
Il name campo è vulnerabile alle iniezioni tempestive, perché il modello potrebbe inavvertitamente interpretarlo come istruzioni. Pertanto, si consiglia di specificare un nome neutro.

Quanto segue mostra un oggetto Message con una content matrice contenente solo un documento ContentBlocke un testo ContentBlockdi accompagnamento obbligatorio.


{
    "role": "user",
    "content": [
        {
            "text": "string"
        },
        {
            "document": {
                "format": "pdf | csv | doc | docx | xls | xlsx | html | txt | md",
                "name": "string",
                "source": {
                    "bytes": "document in bytes"
                }
            }
        }
    ]
}

Gli altri campi ContentBlock sono destinati all'uso degli strumenti.

Specificate il ruolo nel role campo. Il ruolo può essere uno dei seguenti:

utente: l'essere umano che invia messaggi al modello.
assistente: il modello che invia messaggi all'utente umano.

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.

Nell'messagesesempio seguente, l'utente richiede un elenco di tre brani pop e il modello genera un elenco di brani.


[
    {
        "role": "user",
        "content": [
            {
                "text": "Create a list of 3 pop songs."
            }
        ]
    },
    {
        "role": "assistant",
        "content": [
            {
                "text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"As It Was\" by Harry Styles\n2. \"Easy On Me\" by Adele\n3. \"Unholy\" by Sam Smith and Kim Petras"
            }
        ]
    }
]

Un prompt di sistema è un tipo di prompt che fornisce istruzioni o contesto al modello sull'attività che deve svolgere o sul personaggio che deve assumere durante la conversazione. È possibile specificare un elenco di prompt di sistema per la richiesta nel campo system (SystemContentBlock), come illustrato nell'esempio seguente.


[
    {
        "text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist. "
    }
]

Parametri di inferenza

L'API Converse supporta un set base di parametri di inferenza impostati nel campo (). inferenceConfig InferenceConfiguration Il set base di parametri di inferenza è:

maxTokens: il numero massimo di token da consentire nella risposta generata.
stopSequences: un elenco di sequenze di interruzioni. Una sequenza di interruzioni è una sequenza di caratteri che causa l'interruzione della generazione della risposta da parte del modello.
temperatura — La probabilità che il modello selezioni opzioni a maggiore probabilità durante la generazione di una risposta.
TopP: la percentuale di candidati più probabili che il modello considera per il token successivo.

Per ulteriori informazioni, consulta Parametri di inferenza.

L'esempio seguente JSON imposta il parametro di inferenza. temperature


{"temperature": 0.5}

Se il modello che stai utilizzando ha parametri di inferenza aggiuntivi, puoi impostare tali parametri specificandoli come JSON nel campo. additionalModelRequestFields L'esempio seguente JSON mostra come impostaretop_k, che è disponibile nei Anthropic Claude modelli, ma non è un parametro di inferenza di base nell'API dei messaggi.


{"top_k": 200}

È possibile specificare i percorsi per i parametri aggiuntivi del modello nel additionalModelResponseFieldPaths campo, come mostrato nell'esempio seguente.


[ "/stop_sequence" ]

L'API restituisce i campi aggiuntivi richiesti nel additionalModelResponseFields campo.

Risposta

La risposta che ricevi dall'API Converse dipende dall'operazione che chiami Converse oConverseStream.

Argomenti

Risposta Converse
ConverseStream risposta

Risposta Converse

Nel modulo di rispostaConverse, il output campo (ConverseOutput) contiene il messaggio (Message) generato dal modello. Il contenuto del messaggio si trova nel campo content (ContentBlock) e il ruolo (useroassistant) a cui corrisponde il messaggio è nel role campo.

Il metrics campo (ConverseMetrics) include le metriche per la chiamata. Per determinare il motivo per cui il modello ha smesso di generare contenuti, controlla il stopReason campo. Puoi ottenere informazioni sui token passati al modello nella richiesta e sui token generati nella risposta controllando il usage campo () TokenUsage. Se hai specificato campi di risposta aggiuntivi nella richiesta, l'API li restituisce come JSON nel campo. additionalModelResponseFields

L'esempio seguente mostra la risposta ottenuta Converse quando si passa il prompt discusso in. Richiesta


{
    "output": {
        "message": {
            "role": "assistant",
            "content": [
                {
                    "text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"Wannabe\" by Spice Girls\n2. \"Bitter Sweet Symphony\" by The Verve \n3. \"Don't Look Back in Anger\" by Oasis"
                }
            ]
        }
    },
    "stopReason": "end_turn",
    "usage": {
        "inputTokens": 125,
        "outputTokens": 60,
        "totalTokens": 185
    },
    "metrics": {
        "latencyMs": 1175
    }
}

ConverseStream risposta

Se chiami ConverseStream per trasmettere in streaming la risposta da un modello, il flusso viene restituito nel campo di stream risposta. Lo stream emette i seguenti eventi nell'ordine seguente.

messageStart(MessageStartEvent). L'evento di inizio di un messaggio. Include il ruolo del messaggio.
contentBlockStart(ContentBlockStartEvent). Un evento di avvio del blocco di contenuto. Solo uso dello strumento.
contentBlockDelta(ContentBlockDeltaEvent). Un evento delta del blocco di contenuto. Include il testo parziale generato dal modello o l'input json parziale per l'uso dello strumento.
contentBlockStop(ContentBlockStopEvent). Un evento Content Block Stop.
messageStop(MessageStopEvent). L'evento di interruzione del messaggio. Include il motivo per cui il modello ha smesso di generare output.
metadata(ConverseStreamMetadataEvent). Metadati per la richiesta. I metadati includono l'utilizzo del token in usage (TokenUsage) e le metriche per la chiamata in metrics (). ConverseStreamMetadataEvent

ConverseStream trasmette un blocco di contenuto completo come ContentBlockStartEvent evento, uno o più ContentBlockDeltaEvent eventi e un evento. ContentBlockStopEvent Usa il contentBlockIndex campo come indice per correlare gli eventi che compongono un blocco di contenuto.

L'esempio seguente è una risposta parziale diConverseStream.


{'messageStart': {'role': 'assistant'}}
{'contentBlockDelta': {'delta': {'text': ''}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ' Title'}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ':'}, 'contentBlockIndex': 0}}
.
.
.
{'contentBlockDelta': {'delta': {'text': ' The'}, 'contentBlockIndex': 0}}
{'messageStop': {'stopReason': 'max_tokens'}}
{'metadata': {'usage': {'inputTokens': 47, 'outputTokens': 20, 'totalTokens': 67}, 'metrics': {'latencyMs': 100.0}}}

Esempi di API Converse

Gli esempi seguenti mostrano come utilizzare le ConverseStream operazioni Converse and.

Argomenti

Conversation with text message example

Questo esempio mostra come chiamare l'Converseoperazione con il AnthropicClaude 3 Sonnetmodello. L'esempio mostra come inviare il testo di input, i parametri di inferenza e i parametri aggiuntivi che sono unici per il modello. Il codice avvia una conversazione chiedendo al modello di creare un elenco di brani. Quindi continua la conversazione chiedendo che le canzoni siano di artisti del Regno Unito.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with Anthropic Claude 3 Sonnet (on demand).
"""

import logging
import boto3

from botocore.exceptions import ClientError


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


def generate_conversation(bedrock_client,
                          model_id,
                          system_prompts,
                          messages):
    """
    Sends messages to a model.
    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The model ID to use.
        system_prompts (JSON) : The system prompts for the model to use.
        messages (JSON) : The messages to send to the model.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Inference parameters to use.
    temperature = 0.5
    top_k = 200

    # Base inference parameters to use.
    inference_config = {"temperature": temperature}
    # Additional inference parameters to use.
    additional_model_fields = {"top_k": top_k}

    # Send the message.
    response = bedrock_client.converse(
        modelId=model_id,
        messages=messages,
        system=system_prompts,
        inferenceConfig=inference_config,
        additionalModelRequestFields=additional_model_fields
    )

    # Log token usage.
    token_usage = response['usage']
    logger.info("Input tokens: %s", token_usage['inputTokens'])
    logger.info("Output tokens: %s", token_usage['outputTokens'])
    logger.info("Total tokens: %s", token_usage['totalTokens'])
    logger.info("Stop reason: %s", response['stopReason'])

    return response

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

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "anthropic.claude-3-sonnet-20240229-v1:0"

    # Setup the system prompts and messages to send to the model.
    system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music."
                       "Only return song names and the artist."}]
    message_1 = {
        "role": "user",
        "content": [{"text": "Create a list of 3 pop songs."}]
    }
    message_2 = {
        "role": "user",
        "content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
    }
    messages = []

    try:

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

        # Start the conversation with the 1st message.
        messages.append(message_1)
        response = generate_conversation(
            bedrock_client, model_id, system_prompts, messages)

        # Add the response message to the conversation.
        output_message = response['output']['message']
        messages.append(output_message)

        # Continue the conversation with the 2nd message.
        messages.append(message_2)
        response = generate_conversation(
            bedrock_client, model_id, system_prompts, messages)

        output_message = response['output']['message']
        messages.append(output_message)

        # Show the complete conversation.
        for message in messages:
            print(f"Role: {message['role']}")
            for content in message['content']:
                print(f"Text: {content['text']}")
            print()

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

    else:
        print(
            f"Finished generating text with model {model_id}.")


if __name__ == "__main__":
    main()

Conversation with image example

Questo esempio mostra come inviare un'immagine come parte di un messaggio e richiede che il modello descriva l'immagine. L'esempio utilizza Converse l'operazione e il AnthropicClaude 3 Sonnetmodello.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an image with the Converse API to Anthropic Claude 3 Sonnet (on demand).
"""

import logging
import boto3


from botocore.exceptions import ClientError


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


def generate_conversation(bedrock_client,
                          model_id,
                          input_text,
                          input_image):
    """
    Sends a message to a model.
    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The model ID to use.
        input text : The input message.
        input_image : The input image.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Message to send.

    with open(input_image, "rb") as f:
        image = f.read()

    message = {
        "role": "user",
        "content": [
            {
                "text": input_text
            },
            {
                    "image": {
                        "format": 'png',
                        "source": {
                            "bytes": image
                        }
                    }
            }
        ]
    }

    messages = [message]

    # Send the message.
    response = bedrock_client.converse(
        modelId=model_id,
        messages=messages
    )

    return response


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

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

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

    try:

        bedrock_client = boto3.client(service_name="bedrock-runtime")

        response = generate_conversation(
            bedrock_client, model_id, input_text, input_image)

        output_message = response['output']['message']

        print(f"Role: {output_message['role']}")

        for content in output_message['content']:
            print(f"Text: {content['text']}")

        token_usage = response['usage']
        print(f"Input tokens:  {token_usage['inputTokens']}")
        print(f"Output tokens:  {token_usage['outputTokens']}")
        print(f"Total tokens:  {token_usage['totalTokens']}")
        print(f"Stop reason: {response['stopReason']}")

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

    else:
        print(
            f"Finished generating text with model {model_id}.")


if __name__ == "__main__":
    main()

Conversation with document example

Questo esempio mostra come inviare un documento come parte di un messaggio e richiede che il modello descriva il contenuto del documento. L'esempio utilizza Converse l'operazione e il AnthropicClaude 3 Sonnetmodello.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an document as part of a message to Anthropic Claude 3 Sonnet (on demand).
"""

import logging
import boto3


from botocore.exceptions import ClientError


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


def generate_message(bedrock_client,
                     model_id,
                     input_text,
                     input_document):
    """
    Sends a message to a model.
    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The model ID to use.
        input text : The input message.
        input_document : The input document.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Message to send.

    message = {
        "role": "user",
        "content": [
            {
                "text": input_text
            },
            {
                "document": {
                    "name": "MyDocument",
                    "format": "txt",
                    "source": {
                        "bytes": input_document
                    }
                }
            }
        ]
    }

    messages = [message]

    # Send the message.
    response = bedrock_client.converse(
        modelId=model_id,
        messages=messages
    )

    return response


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

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
    input_text = "What's in this document?"
    input_document = 'path/to/document.pdf'

    try:

        bedrock_client = boto3.client(service_name="bedrock-runtime")


        response = generate_message(
            bedrock_client, model_id, input_text, input_document)

        output_message = response['output']['message']

        print(f"Role: {output_message['role']}")

        for content in output_message['content']:
            print(f"Text: {content['text']}")

        token_usage = response['usage']
        print(f"Input tokens:  {token_usage['inputTokens']}")
        print(f"Output tokens:  {token_usage['outputTokens']}")
        print(f"Total tokens:  {token_usage['totalTokens']}")
        print(f"Stop reason: {response['stopReason']}")

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

    else:
        print(
            f"Finished generating text with model {model_id}.")


if __name__ == "__main__":
    main()

Conversation streaming example

Questo esempio mostra come chiamare l'ConverseStreamoperazione con il AnthropicClaude 3 Sonnetmodello. L'esempio mostra come inviare il testo di input, i parametri di inferenza e i parametri aggiuntivi che sono unici per il modello.


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

import logging
import boto3


from botocore.exceptions import ClientError


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


def stream_conversation(bedrock_client,
                    model_id,
                    messages,
                    system_prompts,
                    inference_config,
                    additional_model_fields):
    """
    Sends messages to a model and streams the response.
    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The model ID to use.
        messages (JSON) : The messages to send.
        system_prompts (JSON) : The system prompts to send.
        inference_config (JSON) : The inference configuration to use.
        additional_model_fields (JSON) : Additional model fields to use.

    Returns:
        Nothing.

    """

    logger.info("Streaming messages with model %s", model_id)

    response = bedrock_client.converse_stream(
        modelId=model_id,
        messages=messages,
        system=system_prompts,
        inferenceConfig=inference_config,
        additionalModelRequestFields=additional_model_fields
    )

    stream = response.get('stream')
    if stream:
        for event in stream:

            if 'messageStart' in event:
                print(f"\nRole: {event['messageStart']['role']}")

            if 'contentBlockDelta' in event:
                print(event['contentBlockDelta']['delta']['text'], end="")

            if 'messageStop' in event:
                print(f"\nStop reason: {event['messageStop']['stopReason']}")

            if 'metadata' in event:
                metadata = event['metadata']
                if 'usage' in metadata:
                    print("\nToken usage")
                    print(f"Input tokens: {metadata['usage']['inputTokens']}")
                    print(
                        f":Output tokens: {metadata['usage']['outputTokens']}")
                    print(f":Total tokens: {metadata['usage']['totalTokens']}")
                if 'metrics' in event['metadata']:
                    print(
                        f"Latency: {metadata['metrics']['latencyMs']} milliseconds")


def main():
    """
    Entrypoint for streaming message API response example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
    system_prompt = """You are an app that creates playlists for a radio station
      that plays rock and pop music. Only return song names and the artist."""

    # Message to send to the model.
    input_text = "Create a list of 3 pop songs."

    message = {
        "role": "user",
        "content": [{"text": input_text}]
    }
    messages = [message]
    
    # System prompts.
    system_prompts = [{"text" : system_prompt}]

    # inference parameters to use.
    temperature = 0.5
    top_k = 200
    # Base inference parameters.
    inference_config = {
        "temperature": temperature
    }
    # Additional model inference parameters.
    additional_model_fields = {"top_k": top_k}

    try:
        bedrock_client = boto3.client(service_name='bedrock-runtime')

        stream_conversation(bedrock_client, model_id, messages,
                        system_prompts, inference_config, additional_model_fields)

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

    else:
        print(
            f"Finished streaming messages with model {model_id}.")


if __name__ == "__main__":
    main()

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Esegui l'inferenza a prompt singolo

Esecuzione dell'inferenza batch