Nodi per il controllo della logica del flusso rapido Nodi per la gestione dei dati nel flusso di prompt Tabelle riassuntive per i tipi di nodi

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. Nell'API, utilizza il type campo e il corrispondente FlowNodeConfigurationnel configuration campo.
Input: fornisci un nome e un tipo di dati per ogni input. Alcuni nodi hanno nomi o tipi predefiniti che è necessario utilizzare. Per sapere quali hanno nomi predefiniti, consulta. Tipi di nodi logici Nel campo dell'espressione, definisci la parte dell'intero input da utilizzare come input individuale. Per ulteriori informazioni, consulta Usa le espressioni per definire gli input estraendo la parte rilevante di un intero input.
Output: fornisci un nome e un tipo di dati per ogni output. Alcuni nodi hanno nomi o tipi predefiniti che è necessario utilizzare. Per sapere quali hanno nomi predefiniti, consulta. Tipi di nodi logici
Configurazione: nella console, si definiscono i campi specifici del nodo nella parte superiore del nodo. Nell'API, utilizza i campi appropriati FlowNodeConfiguratione compila i relativi campi.

Ogni tipo di nodo è descritto di seguito e viene fornita la sua struttura nell'API. 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 nell'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. Nell'API, l'output viene restituito flowOutputEvent nel content campo della InvokeFlow risposta. Un prompt flow 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 definire un nodo di condizione

Aggiungi tutti gli input necessari per valutare le condizioni che intendi aggiungere.
Inserisci un nome per ogni input, specifica il tipo da aspettarti e scrivi un'espressione per estrarre la parte rilevante dall'intero input.
Connect ogni ingresso all'uscita pertinente da un nodo upstream.
Aggiungi tutte le condizioni di cui hai bisogno.
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)

Nell'API, definisci quanto segue nel definition campo quando invii una UpdateFlowrichiesta CreateFlowo:

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": {
        "conditions": [
            {
                "name": "string",
                "expression": "string"
            },
            ...
        ]
    }
}

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"
        }
    }
}

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. 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 Gestione tempestiva in Amazon Bedrock.

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 scheda API 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 FM e le risorse associate per identificare ed eseguire azioni per un utente finale. Per ulteriori informazioni, consulta Agenti per Amazon Bedrock.

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 Basi di conoscenza per Amazon Bedrock.

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 l'URI della 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": "storageS3Uri",
            "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 con codifica UTF-8.

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


{
    "name": "string",
    "type": "Retrieval",
    "inputs": [
        {
            "name": "retrievalObjectKey"
            "type": "String",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "retrievalNodeContent",
            "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. Per ulteriori informazioni, consulta la Guida per gli sviluppatori di AWS Lambda.

Nella configurazione, specifica l'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 come 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"
        }
    }
}

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 riepilogano 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	Type	Output	Nome	Type
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
Iteratore		`array`	Array	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
Collezionista	La dimensione dell'array di output	`arraySize`	Numero	Un array con tutti gli output del nodo precedente aggiunti.	`collectedArray`	Array

Tipi di nodi di elaborazione dati
	Informazioni di input			Informazioni sull'output
Tipo di nodo	Input	Nome	Type	Output	Nome	Type
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	L'URI della posizione S3.	`storageS3Uri`	Stringa
Archiviazione S3	La chiave dell'oggetto da usare per l'oggetto S3.	`objectKey`	Stringa	L'URI della posizione S3.	`storageS3Uri`	Stringa
Recupero S3	La chiave dell'oggetto per l'oggetto S3	`retrievalObjectKey`	Stringa	I dati da recuperare da un bucket S3.	`retrievalNodeContent`	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

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

Definisci gli input con le espressioni

Esempi di flussi di prompt