Esegui esempi di codice di Amazon Bedrock Prompt flows

Nota

I flussi di Amazon Bedrock Prompt sono disponibili in anteprima e sono soggetti a modifiche.

I seguenti esempi di codice presuppongono che tu abbia soddisfatto i seguenti prerequisiti:

Configura un ruolo per avere le autorizzazioni per le azioni di Amazon Bedrock. In caso contrario, consulta. Guida introduttiva ad Amazon Bedrock
Imposta le tue credenziali per utilizzare il AWS API. Se non l'hai fatto, fai riferimento a. Guida introduttiva all' AWS API
Crea un ruolo di servizio per eseguire azioni tempestive relative al flusso per tuo conto. Se non l'hai fatto, fai riferimento a. Crea un ruolo di servizio per i flussi Amazon Bedrock Prompt in Amazon Bedrock

Per provare alcuni esempi di codice per i flussi Amazon Bedrock Prompt, seleziona la scheda corrispondente al metodo che preferisci e segui i passaggi:

Python

Crea un flusso di prompt utilizzando una CreateFlowrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli sui campi) con un endpoint di build Agents for Amazon Bedrock con i seguenti nodi:

Un nodo di input.
Un nodo prompt con un prompt definito in linea che crea una playlist musicale utilizzando due variabili (genree). number
Un nodo di output che restituisce il completamento del modello.

Esegui il seguente frammento di codice per caricare AWS SDK for Python (Boto3), creare un client Amazon Bedrock Agents e creare un flusso di prompt con i nodi (sostituisci il executionRoleArn campo con il ruolo ARN di servizio che hai creato per il prompt flow):


# Import Python SDK and create client
import boto3

client = boto3.client(service_name='bedrock-agent')

# Replace with the service role that you created. For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-permissions.html
FLOWS_SERVICE_ROLE = "arn:aws:iam::123456789012:role/MyPromptFlowsRole"

# Define each node

# The input node validates that the content of the InvokeFlow request is a JSON object.
input_node = {
    "type": "Input",
    "name": "FlowInput",
    "outputs": [
        {
            "name": "document",
            "type": "Object"
        }
    ]
}

# This prompt node defines an inline prompt that creates a music playlist using two variables.
# 1. {{genre}} - The genre of music to create a playlist for
# 2. {{number}} - The number of songs to include in the playlist
# It validates that the input is a JSON object that minimally contains the fields "genre" and "number", which it will map to the prompt variables.
# The output must be named "modelCompletion" and be of the type "String".
prompt_node = {
    "type": "Prompt",
    "name": "MakePlaylist",
    "configuration": {
        "prompt": {
            "sourceConfiguration": {
                "inline": {
                    "modelId": "amazon.titan-text-express-v1",
                    "templateType": "TEXT",
                    "inferenceConfiguration": {
                        "text": {
                            "temperature": 0.8
                        }
                    },
                    "templateConfiguration": { 
                        "text": {
                            "text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
                        }
                    }
                }
            }
        }
    },
    "inputs": [
        {
            "name": "genre",
            "type": "String",
            "expression": "$.data.genre"
        },
        {
            "name": "number",
            "type": "Number",
            "expression": "$.data.number"
        }
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ]
}

# The output node validates that the output from the last node is a string and returns it as is. The name must be "document".
output_node = {
    "type": "Output",
    "name": "FlowOutput",
    "inputs": [
        {
            "name": "document",
            "type": "String",
            "expression": "$.data"
        }
    ]
}

# Create connections between the nodes
connections = []

#   First, create connections between the output of the flow input node and each input of the prompt node
for input in prompt_node["inputs"]:
    connections.append(
        {
            "name": "_".join([input_node["name"], prompt_node["name"], input["name"]]),
            "source": input_node["name"],
            "target": prompt_node["name"],
            "type": "Data",
            "configuration": {
                "data": {
                    "sourceOutput": input_node["outputs"][0]["name"],
                    "targetInput": input["name"]
                }
            }
        }
    )

# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
    {
        "name": "_".join([prompt_node["name"], output_node["name"]]),
        "source": prompt_node["name"],
        "target": output_node["name"],
        "type": "Data",
        "configuration": {
            "data": {
                "sourceOutput": prompt_node["outputs"][0]["name"],
                "targetInput": output_node["inputs"][0]["name"]
            }
        }
    }
)

# Create the flow from the nodes and connections
response = client.create_flow(
    name="FlowCreatePlaylist",
    description="A flow that creates a playlist given a genre and number of songs to include in the playlist.",
    executionRoleArn=FLOWS_SERVICE_ROLE,
    definition={
        "nodes": [input_node, prompt_node, output_node],
        "connections": connections
    }
)

flow_id = response.get("id")

Elenca i flussi di prompt nel tuo account, incluso quello che hai appena creato, eseguendo il seguente frammento di codice per effettuare una ListFlowsrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di compilazione Agents for Amazon Bedrock:
```
client.list_flows()
```
Ottieni informazioni sul flusso di prompt che hai appena creato eseguendo il seguente frammento di codice per effettuare una GetFlowrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint in fase di costruzione di Agents for Amazon Bedrock:
```
client.get_flow(flowIdentifier=flow_id)
```
Prepara il flusso di prompt in modo che vengano applicate le ultime modifiche della bozza di lavoro e che sia pronto per la versione. Esegui il seguente frammento di codice per effettuare una PrepareFlowrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint in fase di costruzione di Agents for Amazon Bedrock:
```
client.prepare_flow(flowIdentifier=flow_id)
```
Modifica la bozza di lavoro del flusso di prompt per creare un'istantanea statica del flusso di prompt e quindi recupera le informazioni al riguardo con le seguenti azioni:
1. Crea una versione eseguendo il seguente frammento di codice per effettuare una CreateFlowVersionrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di build Agents for Amazon Bedrock:
```
response = client.create_flow_version(flowIdentifier=flow_id)
                                
flow_version = response.get("version")
```
2. Elenca tutte le versioni del flusso di prompt eseguendo il seguente frammento di codice per effettuare una ListFlowVersionsrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli del campo) con un endpoint di build Agents for Amazon Bedrock:
```
client.list_flow_versions(flowIdentifier=flow_id)
```
3. Ottieni informazioni sulla versione eseguendo il seguente frammento di codice per effettuare una GetFlowVersionrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di build Agents for Amazon Bedrock:
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
Crea un alias per indicare la versione del flusso di prompt che hai creato, quindi recupera le relative informazioni con le seguenti azioni:
1. Crea un alias e indirizzalo alla versione che hai appena creato eseguendo il seguente frammento di codice per effettuare una CreateFlowAliasrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli del campo) con un endpoint di compilazione di Agents for Amazon Bedrock:
```
response = client.create_flow_alias(
    flowIdentifier="FLOW123456",
    name="latest",
    description="Alias pointing to the latest version of the flow.",
    routingConfiguration=[
        {
            "flowVersion": flow_version
        }
    ]
)

flow_alias_id = response.get("id")
```
2. Elenca tutti gli alias del flusso di prompt eseguendo il seguente frammento di codice per effettuare una ListFlowAliassrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli del campo) con un endpoint di build Agents for Amazon Bedrock:
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
3. Ottieni informazioni sull'alias che hai appena creato eseguendo il seguente frammento di codice per effettuare una GetFlowAliasrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli del campo) con un endpoint in fase di costruzione di Agents for Amazon Bedrock:
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```

Esegui il seguente frammento di codice per creare un client Amazon Bedrock Agents Runtime e richiamare un flusso. La richiesta inserisce le variabili del prompt nel flusso di prompt e restituisce la risposta del modello per effettuare una InvokeFlowrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli del campo) con un endpoint di runtime Agents for Amazon Bedrock:


client_runtime = boto3.client('bedrock-agent-runtime')

response = client_runtime.invoke_flow(
    flowIdentifier=flow_id,
    flowAliasIdentifier=flow_alias_id,
    inputs=[
        {
            "content": {
                "document": {
                    "genre": "pop",
                    "number": 3
                }
            },
            "nodeName": "FlowInput",
            "nodeOutputName": "document"
        }
    ]
)

result = {}

for event in response.get("responseStream"):
    result.update(event)

if result['flowCompletionEvent']['completionReason'] == 'SUCCESS':
    print("Prompt flow invocation was successful! The output of the prompt flow is as follows:\n")
    print(result['flowOutputEvent']['content']['document'])

else:
    print("The prompt flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])

La risposta dovrebbe restituire una playlist di musica pop con tre brani.

Elimina l'alias, la versione e il flusso di prompt che hai creato con le seguenti azioni:
1. Elimina l'alias eseguendo il seguente frammento di codice per effettuare una DeleteFlowAliasrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di build Agents for Amazon Bedrock:
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
2. Elimina la versione eseguendo il seguente frammento di codice per effettuare una DeleteFlowVersionrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di build Agents for Amazon Bedrock:
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
3. Elimina il flusso eseguendo il seguente frammento di codice per effettuare una DeleteFlowrichiesta (consulta il link per i formati di richiesta e risposta e i dettagli dei campi) con un endpoint di build Agents for Amazon Bedrock:
```
client.delete_flow(flowIdentifier=flow_id)
```

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

Eliminare un flusso di prompt

Personalizza il modello per il tuo caso d'uso