Tipi di nodi nel flusso rapido - Amazon Bedrock
Nodi per il controllo della logica del flusso rapidoNodi per la gestione dei dati nel flusso di promptTabelle riassuntive per i tipi di nodi

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tipi di nodi nel flusso rapido

Amazon Bedrock fornisce i seguenti tipi di nodi per creare il flusso di prompt. Quando configuri un nodo, devi fornire i seguenti campi:

  • Nome: inserisci un nome per il nodo.

  • Tipo: nella console, trascini il tipo di nodo da utilizzare. InAPI, usa il type campo e il corrispondente FlowNodeConfigurationnel configuration campo.

  • Ingressi: fornisci le seguenti informazioni per ogni input:

  • Output: fornisci le seguenti informazioni per ogni output:

    • Nome: un nome per l'output. Alcuni nodi hanno nomi o tipi predefiniti che è necessario utilizzare. Per sapere quali hanno nomi predefiniti, consulta. Tipi di nodi logici

    • Tipo: il tipo di dati per l'output. Quando questo nodo viene raggiunto in fase di esecuzione, Amazon Bedrock verifica che l'output del nodo corrisponda al tipo di dati.

  • Configurazione: nella console, definisci i campi specifici del nodo nella parte superiore del nodo. NelAPI, usa i campi appropriati FlowNodeConfiguratione compila i relativi campi.

Ogni tipo di nodo è descritto di seguito e API viene fornita la sua struttura in. Espandi una sezione per saperne di più su quel tipo di nodo.

Nodi per il controllo della logica del flusso rapido

Utilizza i seguenti tipi di nodi per controllare la logica del flusso di prompt.

Ogni flusso di prompt contiene solo un nodo di input del flusso e deve iniziare con esso. Il nodo di input del flusso prende il content dalla InvokeFlow richiesta, convalida il tipo di dati e lo invia al nodo successivo.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto di input in: API

{
    "name": "string",
    "type": "Input",
    "outputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
        }
    ],
    "configuration": {
        "input": CONTEXT-DEPENDENT
    }
}

Un nodo di output del flusso estrae i dati di input dal nodo precedente, in base all'espressione definita, e li restituisce. Nella console, l'output è la risposta restituita dopo aver scelto Esegui nella finestra di test. InAPI, l'output viene restituito flowOutputEvent nel content campo della InvokeFlow risposta. Un flusso rapido può avere più nodi di output del flusso.

Un flusso può avere più nodi di output del flusso se vi sono più rami nel flusso.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto di output:

{
    "name": "string",
    "type": "Output",
    "inputs": [
        {
            "name": "document",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "output": CONTEXT-DEPENDENT
    }
}

Un nodo di condizione invia i dati dal nodo precedente a nodi diversi, a seconda delle condizioni definite. Un nodo di condizione può ricevere più input.

Per vedere un esempio, consulta Crea un flusso con un nodo di condizione.

Per definire un nodo di condizione

  1. Aggiungi tutti gli input necessari per valutare le condizioni che intendi aggiungere.

  2. Inserisci un nome per ogni input, specifica il tipo da aspettarti e scrivi un'espressione per estrarre la parte rilevante dall'intero input.

  3. Connect ogni ingresso all'uscita pertinente da un nodo upstream.

  4. Aggiungi tutte le condizioni di cui hai bisogno.

  5. Per ogni condizione:

    1. Inserisci un nome per la condizione.

    2. Utilizzate gli operatori relazionali e logici per definire una condizione che confronta gli input con altri input o con una costante.

      Nota

      Le condizioni vengono valutate in ordine. Se viene soddisfatta più di una condizione, la condizione precedente ha la precedenza.

    3. Connect ogni condizione al nodo downstream a cui si desidera inviare i dati se tale condizione è soddisfatta.

Espressioni di condizione

Per definire una condizione, fate riferimento a un input con il suo nome e lo confrontate con un valore utilizzando uno dei seguenti operatori relazionali:

Operatore Significato Tipi di dati supportati Esempio di utilizzo Significato di esempio
== Uguale a (anche il tipo di dati deve essere uguale) Stringa, numero, booleano A = B Se A è uguale a B
!= Non è uguale a Stringa, numero, booleano UN! = B Se A non è uguale a B
> Maggiore di Numero A > B Se A è maggiore di B
>= Maggiore o uguale a Numero A >= B Se A è maggiore o uguale a B
< Minore di Numero A < B Se A è minore di B
<= Minore o uguale a Numero A <= B Se A è minore o uguale a B

È possibile confrontare gli input con altri input o con una costante in un'espressione condizionale. Ad esempio, se avete un input numerico chiamato profit e un altro chiamatoexpenses, entrambi profit > expenses o profit <= 1000 due sono espressioni valide.

È possibile utilizzare i seguenti operatori logici per combinare espressioni per condizioni più complesse. Si consiglia di utilizzare le parentesi per risolvere le ambiguità nel raggruppamento di espressioni:

Operatore Significato Esempio di utilizzo Esempio di significato
e Entrambe le espressioni sono vere (A < B) e (C == 1) Se entrambe le espressioni sono vere:

  • A è minore di B

  • C è uguale a 1
oppure Almeno un'espressione è vera (A! = 2) o (B > C) Se una delle due espressioni è vera:

  • A non è uguale a B

  • B è maggiore di C
not L'espressione non è vera non (A > B) Se A non è maggiore di B (equivalente a A <= B)

InAPI, definisci quanto segue nel definition campo quando invii una UpdateFlowrichiesta CreateFlowo:

  1. Un FlowNodeoggetto condizionale nell'nodesarray. Il formato generale è il seguente (si noti che i nodi condizionali non hannooutputs):

    {
    "name": "string",
    "type": "Condition",
    "inputs": [
        {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "configuration": {
        "condition": {
            "conditions": [
                {
                    "name": "string",
                    "expression": "string"
                },
                ...
            ]
        }
    }
}

  2. Per ogni input nel nodo di condizione, un FlowConnectionoggetto nell'connectionsarray. Includi un FlowDataConnectionConfigurationoggetto nel configuration campo dell'FlowConnectionoggetto. Il formato generale dell'FlowConnectionoggetto è il seguente:

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "data": {
            "sourceOutput": "string",
            "expression": "string"
        }
    }
}

  3. Per ogni condizione (inclusa la condizione predefinita) nel nodo condizione, un FlowConnectionoggetto nell'connectionsarray. Includi un FlowConditionalConnectionConfigurationoggetto nel configuration campo dell'FlowConnectionoggetto. Il formato generale dell'FlowConnectionoggetto è il seguente:

    {
    "name": "string",
    "source": "string",
    "target": "string",
    "type": "Data",
    "configuration": {
        "condition": "default",
        "condition": "string"
        ...
    }
}

    Utilizzate gli operatori relazionali e logici per definire il condition che collega questo nodo di condizione a un source target nodo a valle. Per la condizione predefinita, specifica la condizione come. default

Un nodo iteratore accetta un array e restituisce iterativamente i suoi elementi come output al nodo a valle. Gli input del nodo iteratore vengono elaborati uno per uno e non in parallelo tra loro. Il nodo flow output restituisce il risultato finale per ogni input in una risposta diversa. È inoltre possibile utilizzare un nodo collettore a valle del nodo iteratore per raccogliere le risposte iterate e restituirle come array, oltre alla dimensione dell'array.

Quanto segue mostra la struttura generale di un oggetto iteratore: FlowNode

{
    "name": "string",
    "type": "Iterator",
    "inputs": [
        {
            "name": "array",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "configuration": {
        "iterator": CONTEXT-DEPENDENT
    }
}

Un nodo collector accetta un input iterato, oltre alla dimensione dell'array, e lo restituisce come array. È possibile utilizzare un nodo collettore a valle di un nodo iteratore per raccogliere gli elementi iterati dopo averli inviati attraverso alcuni nodi.

Di seguito viene illustrata la struttura generale di un oggetto raccoglitore: FlowNode

{
    "name": "string",
    "type": "Collector",
    "inputs": [
        {
            "name": "arrayItem",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "arraySize",
            "type": "Number"
        }
    ],
    "outputs": [
        {
            "name": "collectedArray",
            "type": "Array"
        },
    ],
    "configuration": {
        "collector": CONTEXT-DEPENDENT
    }
}

Nodi per la gestione dei dati nel flusso di prompt

Utilizza i seguenti tipi di nodi per gestire i dati nel flusso di prompt:

Un nodo prompt definisce un prompt da utilizzare nel flusso. È possibile utilizzare un prompt di Prompt management o definirne uno in linea nel nodo. Per ulteriori informazioni, consulta Crea e archivia richieste riutilizzabili con la gestione tempestiva in Amazon Bedrock.

Per vedere un esempio, consulta Inizia con esempi di flussi di prompt.

Gli input del nodo prompt sono valori per compilare le variabili. L'output è la risposta generata dal modello.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto prompt:

{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": PromptFlowNodeSourceConfiguration object (see below)
        }
    }
}

L'PromptFlowNodeSourceConfigurationoggetto dipende se si utilizza un prompt di Prompt management o se lo si definisce in linea:

  • Se si utilizza un prompt di Prompt management, l'oggetto deve avere la seguente struttura generale:

    {
    "resource": {
        "promptArn": "string"
    }
}

  • Se definite un prompt in linea, seguite le indicazioni per la definizione di una variante nella API scheda di Creare un prompt utilizzando la gestione dei prompt (tuttavia, in questo oggetto non è presente alcun name campo). L'oggetto da utilizzare dovrebbe avere la seguente struttura generale:

    {
    "inline": {
        "modelId": "string",
        "templateType": "TEXT",
        "templateConfiguration": {
            "text": {
                "text": "string",
                "inputVariables": [
                    {
                        "name": "string"
                    },
                    ...
                ]
            }
        },
        "inferenceConfiguration": {
            "text": {
                "maxTokens": int,
                "stopSequences": ["string", ...],
                "temperature": float,
                "topK": int,
                "topP": float
            }
        }
    }
}

Un nodo agente consente di inviare un prompt a un agente, che orchestra tra le risorse associate per identificare FMs ed eseguire azioni per un utente finale. Per ulteriori informazioni, consulta Automatizza le attività nella tua applicazione utilizzando agenti conversazionali.

Nella configurazione, specifica l'Amazon Resource Name (ARN) dell'alias dell'agente da utilizzare. Gli input nel nodo sono il prompt dell'agente e qualsiasi attributo di prompt o sessione associato. Il nodo restituisce la risposta dell'agente come output.

Nota

Attualmente, l'agente non supporta le chiamate a turni multipli. Non è possibile configurare il ritorno del controllo per l'agente in un flusso.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto agente:

{
    "name": "string",
    "type": "Agent",
    "inputs": [
       {
            "name": "agentInputText"
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "promptAttributes"
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes"
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "agentResponse",
            "type": "String"
        }
    ],
    "configuration": {
        "agent": {
            "agentAliasArn": "string"
        }
    }
}

Un nodo della knowledge base consente di inviare una query a una knowledge base. Per ulteriori informazioni, consulta Recupera dati e genera risposte AI con le knowledge base.

Nella configurazione, fornisci l'ID della knowledge base e un ID del modello da utilizzare se desideri generare una risposta basata sui risultati recuperati. Per restituire i risultati recuperati come matrice, omettete l'ID del modello. L'input nel nodo è la query alla knowledge base. L'output è la risposta del modello, sotto forma di stringa, o una matrice dei risultati recuperati.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto della knowledge base:

{
    "name": "string",
    "type": "KnowledgeBase",
    "inputs": [
       {
            "name": "retrievalQuery",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalResults",
            "type": "Array | String"
        }
    ],
    "configuration": {
        "knowledgeBase": {
            "knowledgeBaseId": "string",
            "modelId": "string"
        }
    }
}

Un nodo di storage S3 consente di archiviare i dati nel flusso verso una posizione Amazon S3. Nella configurazione, specifichi il bucket S3 da utilizzare per l'archiviazione dei dati. Gli input nel nodo sono il contenuto da archiviare e la chiave dell'oggetto. Il nodo restituisce URI la posizione S3 come output.

Di seguito viene illustrata la struttura generale di un oggetto di storage FlowNodeS3:

{
    "name": "string",
    "type": "Storage",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Uri",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Un nodo di recupero S3 ti consente di recuperare i dati da una posizione Amazon S3 per introdurli al flusso. Nella configurazione, specifichi il bucket S3 da cui recuperare i dati. L'input nel nodo è la chiave dell'oggetto. Il nodo restituisce il contenuto nella posizione S3 come output.

Nota

Attualmente, i dati nella posizione S3 devono essere una stringa codificata UTF -8.

Di seguito viene illustrata la struttura generale di un oggetto di recupero S3: FlowNode

{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "objectKey",
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "s3Content",
            "type": "String"
        }
    ],
    "configuration": {
        "retrieval": {
            "serviceConfiguration": {
                "s3": {
                    "bucketName": "string"
                }
            }
        }
    }
}

Un nodo funzione Lambda consente di chiamare una funzione Lambda in cui è possibile definire il codice per eseguire la logica aziendale. Quando includi un nodo Lambda in un flusso di prompt, Amazon Bedrock invia un evento di input alla funzione Lambda specificata.

Nella configurazione, specifica Amazon Resource Name (ARN) della funzione Lambda. Definisci gli input da inviare nell'evento di input Lambda. Puoi scrivere codice basato su questi input e definire cosa restituisce la funzione. La risposta della funzione viene restituita nell'output.

Di seguito viene illustrata la struttura generale di un FlowNodeoggetto funzionale λ:

{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "functionResponse",
            "type": "String | Number | Boolean | Object | Array"
        }
    ],
    "configuration": {
        "lambdaFunction": {
            "lambdaArn": "string"
        }
    }
}

Evento di input Lambda per un flusso rapido

L'evento di input inviato a una funzione Lambda in un nodo Lambda ha il seguente formato:

{
   "messageVersion": "1.0",
   "flow": {
        "flowArn": "string",
        "flowAliasArn": "string"
   },
   "node": {
        "name": "string",
        "nodeInputs": [
            {
               "name": "string",
               "type": "String | Number | Boolean | Object | Array",
               "expression": "string",
               "value": ...
            },
            ...
        ]
   }
}

I campi per ogni input corrispondono ai campi specificati durante la definizione del nodo Lambda, mentre il valore del value campo viene popolato con l'intero input nel nodo dopo essere stato risolto dall'espressione. Ad esempio, se l'intero input nel nodo è [1, 2, 3] e l'espressione è$.data[1], il valore inviato nell'evento di input alla funzione Lambda sarebbe. 2

Per ulteriori informazioni sugli eventi in Lambda, consulta i concetti di Lambda nella AWS Lambda Guida per gli sviluppatori.

Risposta Lambda per un flusso rapido

Quando scrivi una funzione Lambda, definisci la risposta da essa restituita. Questa risposta viene restituita al flusso di prompt come output del nodo Lambda.

Nota

Il nodo Lex si basa sul servizio Amazon Lex, che può archiviare e utilizzare i contenuti dei clienti per lo sviluppo e il miglioramento continuo di altri AWS servizi. Come AWS cliente, puoi scegliere di non far archiviare o utilizzare i tuoi contenuti per migliorare il servizio. Per informazioni su come implementare una politica di opt-out per Amazon Lex, consulta le politiche di opt-out dei servizi AI.

Un nodo Lex consente di chiamare un bot Amazon Lex per elaborare un enunciato utilizzando l'elaborazione del linguaggio naturale e identificare un intento, in base alla definizione del bot. Per ulteriori informazioni, consulta la Amazon Lex Developer Guide.

Nella configurazione, specifica l'Amazon Resource Name (ARN) dell'alias del bot da utilizzare e il locale da utilizzare. Gli input nel nodo sono l'enunciato e gli eventuali attributi di richiesta o di sessione associati. Il nodo restituisce l'intento identificato come output.

Nota

Attualmente, il nodo Lex non supporta le conversazioni a turni multipli. Un nodo Lex può elaborare un solo enunciato.

Quanto segue mostra la struttura generale di un FlowNodeoggetto Lex:

{
    "name": "string",
    "type": "Lex",
    "inputs": [
       {
            "name": "inputText",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        {
            "name": "requestAttributes",
            "type": "Object",
            "expression": "string"
        },
        {
            "name": "sessionAttributes",
            "type": "Object",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "predictedIntent",
            "type": "String"
        }
    ],
    "configuration": {
        "lex": {
            "botAliasArn": "string",
            "localeId": "string"
        }
    }
}

Tabelle riassuntive per i tipi di nodi

Le tabelle seguenti riassumono gli input e gli output consentiti per ogni tipo di nodo. Tieni presente quanto segue:

  • Se un nome è contrassegnato come Any, puoi fornire qualsiasi stringa come nome. Altrimenti, è necessario utilizzare il valore specificato nella tabella.

  • Se un tipo è contrassegnato come Qualsiasi, è possibile specificare uno dei seguenti tipi di dati: String, Number, Boolean, Object, Array. Altrimenti, è necessario utilizzare il tipo specificato nella tabella.

  • Attualmente, solo i nodi funzione Condition, Prompt e Lambda consentono più input che è possibile definire autonomamente.

Tipi di nodi logici
Informazioni di input Informazioni sull'output
Tipo di nodo Input Nome Tipo Output Nome Tipo
Input N/D N/D N/D Il content campo nella InvokeFlow richiesta. document Qualsiasi
Output Dati da restituire nella InvokeFlow risposta. document Qualsiasi N/D N/D N/D
Condition

Dati da inviare in base a una condizione.

(sono consentiti più ingressi)

 Qualsiasi Qualsiasi

Dati da inviare in base a una condizione.

(specificare le condizioni per percorsi diversi)

 Qualsiasi Qualsiasi
Iteratore Un array per il quale si desidera applicare i seguenti nodi in modo iterativo a ciascun membro. array Array Ogni elemento dell'array arrayItem Qualsiasi
La dimensione dell'array di input arraySize Numero
Collezionista Un'iterazione che si desidera consolidare in un array. arrayItem Qualsiasi Un array con tutti gli output del nodo precedente aggiunti. collectedArray Array
La dimensione dell'array di output arraySize Numero
Tipi di nodi di elaborazione dati
Informazioni di input Informazioni sull'output
Tipo di nodo Input Nome Tipo Output Nome Tipo
Richiesta

Un valore per inserire una variabile nel prompt.

(sono consentiti più ingressi)

 ${variable-name} Qualsiasi La risposta restituita dal modello. modelCompletion Stringa
Archiviazione S3 Dati da archiviare in un bucket S3. content Qualsiasi La URI sede S3. s3Uri Stringa
La chiave dell'oggetto da usare per l'oggetto S3. objectKey Stringa
Recupero S3 La chiave dell'oggetto per l'oggetto S3 objectKey Stringa I dati da recuperare da un bucket S3. s3Content Qualsiasi
Agente Il prompt da inviare all'agente. agentInputText Stringa La risposta restituita dall'agente. agentResponse Stringa
Qualsiasi attributo del prompt da inviare insieme al prompt. promptAttributes Oggetto
Qualsiasi attributo di sessione da inviare insieme al prompt. sessionAttributes Oggetto
Base di conoscenza La richiesta da inviare alla knowledge base. retrievalQuery Stringa I risultati restituiti o la risposta generata dalla knowledge base. retrievalResults Array
Funzione Lambda

Dati da inviare alla funzione.

(sono consentiti più ingressi)

 Qualsiasi La risposta restituita dalla funzione. functionResponse Qualsiasi
Lex L'enunciato da inviare al bot. inputText Stringa L'intento che il bot prevede per l'enunciato. predictedIntent Stringa
Qualsiasi attributo di richiesta da inviare insieme all'enunciato. requestAttributes Oggetto
Qualsiasi attributo di sessione da inviare insieme all'enunciato. sessionAttributes Oggetto