Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Fügen Sie eine Leitplanke hinzu mit Converse API

Du kannst eine Leitplanke verwenden, um Konversations-Apps zu schützen, die du mit dem Converse erstellst. API Zum Beispiel, wenn du eine Chat-App erstellst mit Converse API, können Sie eine Leitplanke verwenden, um unangemessene Inhalte zu blockieren, die vom Benutzer eingegeben wurden, und unangemessene Inhalte, die vom Modell generiert wurden. Für Informationen über die Converse API, sieheFühren Sie ein Gespräch mit dem Converse API-Operationen.

Ich rufe die Converse APImit Leitplanken

Um eine Leitplanke zu verwenden, müssen Sie bei Aufrufen der Converse oder ConverseStreambei Vorgängen (bei Streaming-Antworten) die Konfigurationsinformationen für die Leitplanke angeben. Optional können Sie bestimmte Inhalte in der Nachricht auswählen, die von der Guardrail bewertet werden sollen. Informationen zu den Modellen, die Sie mit Leitplanken verwenden können, und zu Converse API, siehe. Unterstützte Modelle und Modellfunktionen

Konfiguration der Leitplanke, mit der gearbeitet werden soll Converse API

Sie geben die Konfigurationsinformationen für die Leitplanke im Eingabeparameter an. guardrailConfig Die Konfiguration umfasst die ID und die Version der Leitplanke, die Sie verwenden möchten. Sie können die Ablaufverfolgung auch für die Leitplanke aktivieren, wodurch Informationen über den Inhalt bereitgestellt werden, den die Leitplanke blockiert hat.

Bei der Converse Operation guardrailConfig handelt es sich um ein GuardrailConfigurationObjekt, wie im folgenden Beispiel gezeigt.

{
        "guardrailIdentifier": "Guardrail ID",
        "guardrailVersion": "Guardrail version",
        "trace": "enabled"
}

Wenn Sie verwendenConverseStream, übergeben Sie ein GuardrailStreamConfigurationObjekt. Optional können Sie das streamProcessingMode Feld verwenden, um anzugeben, dass das Modell die Guardrail-Assessment abschließen soll, bevor Streaming-Antwort-Chunks zurückgegeben werden. Oder Sie können das Modell asynchron reagieren lassen, während die Guardrail ihre Bewertung im Hintergrund fortsetzt. Weitere Informationen finden Sie unter Konfigurieren Sie das Streaming-Antwortverhalten, um Inhalte zu filtern.

Schutz einer Nachricht zur Bewertung schädlicher Inhalte mithilfe von APIs

Wenn Sie eine Nachricht (Message) an ein Model übergeben, bewertet die Leitplanke den Inhalt der Nachricht. Optional können Sie den ausgewählten Inhalt der Nachricht schützen, indem Sie das Feld guardContent () GuardrailConverseContentBlockangeben. Die Leitplanke bewertet nur den Inhalt des guardContent Felds und nicht den Rest der Nachricht. Dies ist nützlich, damit die Leitplanke nur die meisten Nachrichten in einer Konversation bewertet, wie im folgenden Beispiel gezeigt.

[
    {
        "role": "user",
        "content": [
            {
                "text": "Create a playlist of 2 pop songs."
            }
        ]
    },
    {
        "role": "assistant",
        "content": [
            {
                "text": " Sure! Here are two pop songs:\n1. \"Bad Habits\" by Ed Sheeran\n2. \"All Of The Lights\" by Kanye West\n\nWould you like to add any more songs to this playlist? "
            }
        ]
    },
    {
        "role": "user",
        "content": [
            {
                "guardContent": {
                    "text": {
                        "text": "Create a playlist of 2 heavy metal songs."
                    }
                }
            }
        ]
    }
]

Eine weitere Möglichkeit besteht darin, zusätzlichen Kontext für eine Nachricht bereitzustellen, ohne dass die Leitplanke diesen zusätzlichen Kontext bewertet.

[
    {
        "role": "user",
        "content": [
            {
                "text": "Only answer with a list of songs."
            },
            {
                "guardContent": {
                    "text": {
                        "text": "Create a playlist of heavy metal songs."
                    }
                }
            }
        ]
    }
]

Bewachen einer Systemaufforderung, die an den gesendet wurde Converse API

Sie können Leitplanken mit Systemaufforderungen verwenden, die Sie an die Converse API. Um eine Systemaufforderung zu schützen, geben Sie das Feld guardContent (SystemContentBlock) in der Systemaufforderung an, die Sie an die übergebenAPI, wie im folgenden Beispiel gezeigt.

[
    {
        "guardContent": {
            "text": {
                "text": "Only respond with Welsh heavy metal songs."
            }
        }
    }
]
            

Wenn Sie das guardContent Feld nicht angeben, bewertet die Leitplanke die Systemaufforderungsmeldung nicht.

Verhalten der Leitplanke in der Meldung und in der Systemaufforderung

Die Art und Weise, wie die Schutzplanke guardContent das Feld bewertet, unterscheidet sich zwischen Systemaufforderungen und Meldungen, die Sie in der Nachricht weitergeben.

Verarbeitung der Antwort bei Verwendung von Converse API

Wenn Sie die Converse Operation aufrufen, bewertet die Leitplanke die von Ihnen gesendete Nachricht. Wenn die Leitplanke blockierte Inhalte erkennt, passiert Folgendes.

Die folgende Teilantwort zeigt den Text des blockierten Inhalts und den Trace aus der Guardrail-Bewertung. Die Leitplanke hat den Begriff Schwermetall in der Nachricht blockiert.

{
    "output": {
        "message": {
            "role": "assistant",
            "content": [
                {
                    "text": "Sorry, I can't answer questions about heavy metal music."
                }
            ]
        }
    },
    "stopReason": "guardrail_intervened",
    "usage": {
        "inputTokens": 0,
        "outputTokens": 0,
        "totalTokens": 0
    },
    "metrics": {
        "latencyMs": 721
    },
    "trace": {
        "guardrail": {
            "inputAssessment": {
                "3o06191495ze": {
                    "topicPolicy": {
                        "topics": [
                            {
                                "name": "Heavy metal",
                                "type": "DENY",
                                "action": "BLOCKED"
                            }
                        ]
                    },
                    "invocationMetrics": {
                        "guardrailProcessingLatency": 240,
                        "usage": {
                            "topicPolicyUnits": 1,
                            "contentPolicyUnits": 0,
                            "wordPolicyUnits": 0,
                            "sensitiveInformationPolicyUnits": 0,
                            "sensitiveInformationPolicyFreeUnits": 0,
                            "contextualGroundingPolicyUnits": 0
                        },
                        "guardrailCoverage": {
                            "textCharacters": {
                                "guarded": 39,
                                "total": 72
                            }
                        }
                    }
                }
            }
        }
    }
}

Beispielcode für die Verwendung Converse APImit Leitplanken

Dieses Beispiel zeigt, wie man eine Konversation mit den ConverseStream Operationen Converse und überwacht. Das Beispiel zeigt, wie verhindert werden kann, dass ein Model eine Playlist erstellt, die Songs aus dem Heavy-Metal-Genre enthält.

Converse

Der folgende Code verwendet Ihre Leitplanke bei der Converse Operation.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use a guardrail with the <noloc>Converse</noloc> API.
"""

import logging
import json
import boto3


from botocore.exceptions import ClientError


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


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

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

    """

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

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

    return response


def main():
    """
    Entrypoint for example.
    """

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

    # The model to use.
    model_id="meta.llama3-8b-instruct-v1:0"

    # The ID and version of the guardrail.
    guardrail_id = "Your guardrail ID"
    guardrail_version = "DRAFT"

    # Configuration for the guardrail.
    guardrail_config = {
        "guardrailIdentifier": guardrail_id,
        "guardrailVersion": guardrail_version,
        "trace": "enabled"
    }

    text = "Create a playlist of 2 heavy metal songs."
    context_text = "Only answer with a list of songs."

    # The message for the model and the content that you want the guardrail to assess.
    messages = [
        {
            "role": "user",
            "content": [
                {
                    "text": context_text,
                },
                {
                    "guardContent": {
                        "text": {
                            "text": text
                        }
                    }
                }
            ]
        }
    ]

    try:

        print(json.dumps(messages, indent=4))

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

        response = generate_conversation(
            bedrock_client, model_id, messages, guardrail_config)

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

        if response['stopReason'] == "guardrail_intervened":
            trace = response['trace']
            print("Guardrail trace:")
            print(json.dumps(trace['guardrail'], indent=4))

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

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

ConverseStream

Der folgende Code verwendet Ihre Leitplanke bei der Operation. ConverseStream

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use a guardrail with the ConverseStream operation.
"""

import logging
import json
import boto3


from botocore.exceptions import ClientError


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


def stream_conversation(bedrock_client,
                    model_id,
                    messages,
                    guardrail_config):
    """
    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.
        guardrail_config : Configuration for the guardrail.


    Returns:
        Nothing.

    """

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

    response = bedrock_client.converse_stream(
        modelId=model_id,
        messages=messages,
        guardrailConfig=guardrail_config
    )

    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 'trace' in metadata:
                    print("\nAssessment")
                    print(json.dumps(metadata['trace'], indent=4))


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

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

    # The model to use.
    model_id = "amazon.titan-text-express-v1"

    # The ID and version of the guardrail.
    guardrail_id = "Change to your guardrail ID"
    guardrail_version = "DRAFT"

    # Configuration for the guardrail.
    guardrail_config = {
        "guardrailIdentifier": guardrail_id,
        "guardrailVersion": guardrail_version,
        "trace": "enabled",
        "streamProcessingMode" : "sync"
    }

    text = "Create a playlist of heavy metal songs."
  
    # The message for the model and the content that you want the guardrail to assess.
    messages = [
        {
            "role": "user",
            "content": [
                {
                    "text": text,
                },
                {
                    "guardContent": {
                        "text": {
                            "text": text
                        }
                    }
                }
            ]
        }
    ]

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

        stream_conversation(bedrock_client, model_id, messages,
                        guardrail_config)

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