Unterstützte Modelle und Modellfunktionen Verwenden der Converse-API Converse API-Beispiele

Verwenden Sie die Converse API

Sie können die Amazon Bedrock Converse API verwenden, um Konversationsanwendungen zu erstellen, die Nachrichten an und von einem Amazon Bedrock-Modell senden und empfangen. Sie können beispielsweise einen Chat-Bot erstellen, der eine Konversation über viele Runden führt und eine Persona- oder Tonanpassung verwendet, die auf Ihre Bedürfnisse zugeschnitten ist, z. B. einen hilfreichen Assistenten für den technischen Support.

Um die Converse-API zu verwenden, verwenden Sie die Operationen Converse oder ConverseStream(für Streaming-Antworten), um Nachrichten an ein Model zu senden. Es ist möglich, die vorhandenen Inferenzoperationen (InvokeModeloder InvokeModelWithResponseStream) für Konversationsanwendungen zu verwenden. Wir empfehlen jedoch, die Converse-API zu verwenden, da sie eine konsistente API bietet, die mit allen Amazon Bedrock-Modellen funktioniert, die Nachrichten unterstützen. Das bedeutet, dass Sie Code einmal schreiben und ihn mit verschiedenen Modellen verwenden können. Sollte ein Modell eindeutige Inferenzparameter haben, können Sie mit der Converse-API diese eindeutigen Parameter auch in einer modellspezifischen Struktur übergeben.

Sie können die Converse-API verwenden, um die Verwendung von Tools und Leitplanken in Ihren Anwendungen zu implementieren.

Anmerkung

Bei Mistral AI Meta Open-Source-Modellen bettet die Converse-API deine Eingaben in eine modellspezifische Eingabeaufforderungsvorlage ein, die Konversationen ermöglicht.

Themen

Unterstützte Modelle und Modellfunktionen
Verwenden der Converse-API
Converse API-Beispiele

Unterstützte Modelle und Modellfunktionen

Die Converse-API unterstützt die folgenden Amazon Bedrock-Modelle und Modellfunktionen. Die Converse-API unterstützt keine Einbettungsmodelle (wieTitan Embeddings G1 - Text) oder Modelle zur Bilderzeugung (wie). Stability AI

Modell	Converse	ConverseStream	Systemaufforderungen	Chat mit Dokumenten	Vision	Verwendung des Tools	Verwendung des Streaming-Tools	Leitlinien
AI21 Jamba-Instruct	Ja	Nein	Ja	Nein	Nein	Nein	Nein	Nein
AI21 LabsJurassic-2(Text)	Begrenzt. Keine Chat-Unterstützung.	Nein	Nein	Nein	Nein	Nein	Nein	Ja
TitanAmazon-Modelle	Ja	Ja	Nein	Ja (außerTitan Text Premier)	Nein	Nein	Nein	Ja
AnthropicClaude2 und früher	Ja	Ja	Ja	Ja	Nein	Nein	Nein	Ja
AnthropicClaude3	Ja	Ja	Ja	Ja	Ja	Ja	Ja	Ja
AnthropicClaude3.5	Ja	Ja	Ja	Nein	Ja	Ja	Ja	Ja
Cohere Command	Begrenzt. Keine Chat-Unterstützung.	Begrenzt. Keine Chat-Unterstützung.	Nein	Ja	Nein	Nein	Nein	Ja
Cohere Command Light	Begrenzt. Keine Chat-Unterstützung.	Begrenzt. Keine Chat-Unterstützung.	Nein	Nein	Nein	Nein	Nein	Ja
Cohere und Command R Command R+	Ja	Ja	Ja	Ja	Nein	Ja	Nein	Nein
Meta und Llama 2 Llama 3	Ja	Ja	Ja	Ja	Nein	Nein	Nein	Ja
Mistral AI Instruct	Ja	Ja	Nein	Ja	Nein	Nein	Nein	Ja
Mistral Large	Ja	Ja	Ja	Ja	Nein	Ja	Nein	Ja
Mistral Small	Ja	Ja	Ja	Nein	Nein	Ja	Nein	Ja

Anmerkung

CohereCommand(Text) und AI21 Labs Jurassic-2 (Text) unterstützen keinen Chat mit der Converse-API. Die Modelle können jeweils nur eine Benutzernachricht bearbeiten und den Verlauf einer Konversation nicht verwalten. Sie erhalten eine Fehlermeldung, wenn Sie versuchen, mehr als eine Nachricht weiterzuleiten.

Verwenden der Converse-API

Um die Converse-API zu verwenden, rufen Sie die ConverseStream Operationen Converse oder auf, um Nachrichten an ein Modell zu senden. Zum Aufrufen Converse benötigen Sie eine Genehmigung für den bedrock:InvokeModel Vorgang. Um anzurufenConverseStream, benötigen Sie eine Genehmigung für den bedrock:InvokeModelWithResponseStream Vorgang.

Anforderung

Sie geben das Modell an, das Sie verwenden möchten, indem Sie das modelId Feld festlegen. Eine Liste der Modell-IDs, die Amazon Bedrock unterstützt, finden Sie unterModell-IDs von Amazon Bedrock.

Eine Konversation besteht aus einer Reihe von Nachrichten zwischen dem Benutzer und dem Modell. Sie beginnen eine Konversation, indem Sie als Benutzer (Benutzerrolle) eine Nachricht an das Modell senden. Das Modell, das als Assistent (Assistentenrolle) fungiert, generiert dann eine Antwort, die es in einer Nachricht zurückgibt. Falls gewünscht, können Sie die Konversation fortsetzen, indem Sie weitere Benutzerrollennachrichten an das Modell senden. Um den Konversationskontext beizubehalten, stellen Sie sicher, dass Sie alle Nachrichten, die Sie vom Modell für die Assistentenrolle erhalten, in nachfolgende Anfragen mit einbeziehen. Beispielcode finden Sie unter Converse API-Beispiele.

Sie geben die Nachrichten, die Sie an ein Modell übergeben möchten, in dem messages Feld ein, das einer Reihe von Message-Objekten zugeordnet ist. Jede Nachricht enthält den Inhalt der Nachricht und die Rolle, die die Nachricht in der Konversation spielt.

Anmerkung

Amazon Bedrock speichert keine Texte, Bilder oder Dokumente, die Sie als Inhalt bereitstellen. Die Daten werden nur zur Generierung der Antwort verwendet.

Sie speichern den Inhalt der Nachricht in dem content Feld, das einer Reihe von ContentBlockObjekten zugeordnet ist. In jedem ContentBlockFeld können Sie eines der folgenden Felder angeben (Informationen darüber, welche Modelle welche Modalitäten unterstützen, finden Sie unterUnterstützte Modelle und Modellfunktionen):

text

Das text Feld ist einer Zeichenfolge zugeordnet, die die Eingabeaufforderung angibt. Das text Feld wird zusammen mit anderen Feldern interpretiert, die in demselben Feld angegeben sind ContentBlock.

Das Folgende zeigt ein Message-Objekt mit einem content Array, das nur einen Text enthält ContentBlock:


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

image

Das image Feld ist einem zugeordnet ImageBlock. Übergeben Sie die in Base64 kodierten Rohbytes für ein Bild im bytes Feld. Wenn Sie ein AWS SDK verwenden, müssen Sie die Bytes nicht in Base64 codieren.

Wenn Sie das text Feld ausschließen, beschreibt das Modell das Bild.

Das Folgende zeigt ein Message-Objekt mit einem content Array, das nur ein Bild ContentBlockenthält:


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

document

Das document Feld ist einem DocumentBlockzugeordnet. Wenn Sie eine angebenDocumentBlock, überprüfen Sie, ob Ihre Anfrage den folgenden Einschränkungen entspricht:

In das content Feld des Message-Objekts müssen Sie auch ein text Feld mit einer Aufforderung aufnehmen, die sich auf das Dokument bezieht.
Übergeben Sie die in Base64 kodierten Rohbytes für das Dokument im bytes Feld. Wenn Sie ein AWS SDK verwenden, müssen Sie die Dokument-Bytes nicht in Base64 codieren.
Das name Feld darf nur die folgenden Zeichen enthalten:
- Alphanumerische Zeichen
- Leerzeichen (nicht mehr als eines in einer Reihe)
- Bindestriche
- Klammern
- Eckige Klammern
Anmerkung
Das name Feld ist anfällig für schnelle Injektionen, da das Modell es versehentlich als Anweisungen interpretieren könnte. Daher empfehlen wir, dass Sie einen neutralen Namen angeben.

Im Folgenden wird ein Message-Objekt mit einem content Array gezeigt, das nur ein Dokument ContentBlockund den erforderlichen Begleittext enthält ContentBlock.


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

Die anderen Felder in ContentBlock sind für die Verwendung mit Tools vorgesehen.

Sie geben die Rolle in dem role Feld an. Die Rolle kann eine der folgenden sein:

user — Der Mensch, der Nachrichten an das Modell sendet.
assistant — Das Modell, das Nachrichten an den menschlichen Benutzer zurücksendet.

Anmerkung

Die folgenden Einschränkungen gelten für das content Feld:

Sie können bis zu 20 Bilder hinzufügen. Die Größe, Höhe und Breite jedes Bilds dürfen jeweils nicht mehr als 3,75 MB, 8.000 Pixel und 8.000 Pixel betragen.
Sie können bis zu fünf Dokumente hinzufügen. Die Größe jedes Dokuments darf nicht mehr als 4,5 MB betragen.
Sie können nur Bilder und Dokumente hinzufügen, wenn dies der Fall role istuser.

Im folgenden messages Beispiel fragt der Benutzer nach einer Liste mit drei Popsongs, und das Modell generiert eine Liste von Songs.


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

Eine Systemaufforderung ist eine Art von Aufforderung, die dem Modell Anweisungen oder Kontext zu der Aufgabe, die es ausführen soll, oder zu der Person, die es während der Konversation annehmen soll, bereitstellt. Sie können im Feld system (SystemContentBlock) eine Liste von Systemaufforderungen für die Anforderung angeben, wie im folgenden Beispiel gezeigt.


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

Inferenzparameter

Die Converse-API unterstützt einen Basissatz von Inferenzparametern, die Sie im inferenceConfig Feld () festlegen. InferenceConfiguration Der Basissatz von Inferenzparametern ist:

maxTokens — Die maximale Anzahl von Token, die in der generierten Antwort zulässig sind.
stopSequences — Eine Liste von Stoppsequenzen. Eine Stoppsequenz ist eine Folge von Zeichen, die dazu führt, dass das Modell die Generierung der Antwort beendet.
Temperatur — Die Wahrscheinlichkeit, dass das Modell beim Generieren einer Antwort Optionen mit höherer Wahrscheinlichkeit auswählt.
TopP — Der Prozentsatz der wahrscheinlichsten Kandidaten, die das Modell für das nächste Token berücksichtigt.

Weitere Informationen finden Sie unter Inferenzparameter.

Im folgenden JSON-Beispiel wird der temperature Inferenzparameter festgelegt.


{"temperature": 0.5}

Wenn das von Ihnen verwendete Modell über zusätzliche Inferenzparameter verfügt, können Sie diese Parameter festlegen, indem Sie sie im additionalModelRequestFields Feld als JSON angeben. Das folgende JSON-Beispiel zeigttop_k, wie festgelegt wird. Dieser Parameter ist zwar in Anthropic Claude Modellen verfügbar, aber kein grundlegender Inferenzparameter in der Nachrichten-API.


{"top_k": 200}

Sie können die Pfade für zusätzliche Modellparameter in dem additionalModelResponseFieldPaths Feld angeben, wie im folgenden Beispiel gezeigt.


[ "/stop_sequence" ]

Die API gibt die zusätzlichen Felder zurück, die Sie in dem additionalModelResponseFields Feld anfordern.

Antwort

Die Antwort, die Sie von der Converse-API erhalten, hängt davon ab, welche Operation Sie aufrufen, Converse oderConverseStream.

Themen

Antwort von Converse
ConverseStream Antwort

Antwort von Converse

In der Antwort von Converse enthält das output Feld (ConverseOutput) die Nachricht (Message), die das Modell generiert. Der Nachrichteninhalt befindet sich im Feld content (ContentBlock) und die Rolle (useroderassistant), der die Nachricht entspricht, befindet sich im role Feld.

Das metrics Feld (ConverseMetrics) enthält Metriken für den Anruf. Überprüfen Sie das stopReason Feld, um festzustellen, warum das Modell keine Inhalte mehr generiert hat. Sie können Informationen über die in der Anfrage an das Modell übergebenen Token und die in der Antwort generierten Token abrufen, indem Sie das usage Feld (TokenUsage) überprüfen. Wenn Sie in der Anfrage zusätzliche Antwortfelder angegeben haben, gibt die API sie im additionalModelResponseFields Feld als JSON zurück.

Das folgende Beispiel zeigt die AntwortConverse, wenn Sie die unter beschriebene Aufforderung übergebenAnforderung.


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

Wenn Sie aufrufenConverseStream, um die Antwort von einem Modell zu streamen, wird der Stream im stream Antwortfeld zurückgegeben. Der Stream gibt die folgenden Ereignisse in der folgenden Reihenfolge aus.

messageStart(MessageStartEvent). Das Startereignis für eine Nachricht. Beinhaltet die Rolle für die Nachricht.
contentBlockStart(ContentBlockStartEvent). Ein Startereignis für Inhaltsblöcke. Nur zur Verwendung des Tools.
contentBlockDelta(ContentBlockDeltaEvent). Ein Delta-Ereignis für Inhaltsblöcke. Beinhaltet den Teiltext, den das Modell generiert, oder den Teil der JSON-Eingabe für die Verwendung mit dem Werkzeug.
contentBlockStop(ContentBlockStopEvent). Ein Ereignis zum Stoppen eines Inhaltsblocks.
messageStop(MessageStopEvent). Das Stopp-Ereignis für die Nachricht. Beinhaltet den Grund, warum das Modell keine Ausgabe mehr generiert hat.
metadata(ConverseStreamMetadataEvent). Metadaten für die Anfrage. Die Metadaten umfassen die Token-Verwendung in usage (TokenUsage) und Metriken für den Aufruf in metrics (ConverseStreamMetadataEvent).

ConverseStream streamt einen kompletten Inhaltsblock als ContentBlockStartEvent Ereignis, ein oder mehrere ContentBlockDeltaEvent Ereignisse und ein ContentBlockStopEvent Ereignis. Verwenden Sie das contentBlockIndex Feld als Index, um die Ereignisse zu korrelieren, aus denen ein Inhaltsblock besteht.

Das folgende Beispiel ist eine teilweise Antwort vonConverseStream.


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

Converse API-Beispiele

Die folgenden Beispiele zeigen Ihnen, wie Sie die ConverseStream Operationen Converse und verwenden.

Themen

Conversation with text message example

Dieses Beispiel zeigt, wie die Converse Operation mit dem AnthropicClaude 3 SonnetModell aufgerufen wird. Das Beispiel zeigt, wie der Eingabetext, die Inferenzparameter und zusätzliche Parameter gesendet werden, die für das Modell einzigartig sind. Der Code startet eine Konversation, indem er das Modell auffordert, eine Liste mit Liedern zu erstellen. Anschließend wird die Konversation fortgesetzt, indem gefragt wird, ob die Songs von Künstlern aus dem Vereinigten Königreich stammen.


# 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

Dieses Beispiel zeigt, wie ein Bild als Teil einer Nachricht gesendet wird, und fordert das Modell auf, das Bild zu beschreiben. Das Beispiel verwendet Converse Operation und das AnthropicClaude 3 SonnetModell.


# 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

Dieses Beispiel zeigt, wie ein Dokument als Teil einer Nachricht gesendet wird, und fordert das Modell auf, den Inhalt des Dokuments zu beschreiben. Das Beispiel verwendet Converse Operation und das AnthropicClaude 3 SonnetModell.


# 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

Dieses Beispiel zeigt, wie die ConverseStream Operation mit dem AnthropicClaude 3 SonnetModell aufgerufen wird. Das Beispiel zeigt, wie der Eingabetext, die Inferenzparameter und zusätzliche Parameter gesendet werden, die für das Modell einzigartig sind.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Ausführen einer Inferenz mit einer einzigen Eingabeaufforderung

Ausführen einer Batch-Inferenz