Tipi di nodo per il flusso

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

Di seguito viene illustrata la struttura generale di un oggetto FlowNode 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 nel campo content di flowOutputEvent della risposta InvokeFlow. Un flusso può avere più nodi di output.

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 oggetto FlowNode 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, in base alle condizioni definite. Un nodo di condizione può ricevere più input.

Per vedere un esempio, consultare Creare un flusso con un nodo di condizione.

Espressioni di condizione

Per definire una condizione, fai riferimento a un input tramite il relativo nome e confrontalo con un valore utilizzando uno dei seguenti operatori relazionali.

È possibile confrontare gli input con altri input o con una costante in un’espressione condizionale. Ad esempio, se è presente un input numerico chiamato profit e un altro denominato expenses, sia profit > expenses che profit <= 1000 sono due espressioni valide.

È possibile utilizzare gli operatori logici seguenti per combinare espressioni e creare condizioni più complesse. Si consiglia di utilizzare le parentesi per evitare ambiguità nel raggruppamento delle espressioni:

Nell’API, definisci i seguenti elementi nel campo definition quando invii una richiesta CreateFlow o UpdateFlow:

Un nodo iteratore accetta un array e restituisce i relativi elementi in modo iterativo come output al nodo a valle. Gli input del nodo iteratore vengono elaborati uno per uno e non in parallelo. Il nodo di output del flusso restituisce il risultato finale per ogni input in una risposta distinta. Puoi utilizzare anche un nodo raccoglitore a valle del nodo iteratore per raccogliere le risposte iterate e restituirle come array, insieme alle dimensioni dell’array.

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

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

Un nodo di raccolta accetta un input iterato, oltre alla dimensione dell’array, e lo restituisce come array. Puoi utilizzare un nodo di raccolta 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 FlowNode di raccolta:

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

Un nodo di loop DoWhile esegue ripetutamente una sequenza di nodi finché una condizione specificata rimane vera. Il loop viene eseguito almeno una volta prima di valutare la condizione, il che lo rende ideale per gli scenari in cui è necessario eseguire un’azione e quindi verificare se deve essere ripetuta in base al risultato.

Il nodo di loop DoWhile ottiene dati di input e li trasmette attraverso il body del loop. Dopo ogni iterazione, la condizione viene valutata per determinare se continuare il loop o uscire. Il loop continua finché la condizione restituisce true o maxIterations non viene superato.

Di seguito viene mostrata la struttura generale di un oggetto FlowNode del loop DoWhile:

{
    "name": "string",
    "type": "DoWhile",
    "inputs": [
        {
            "name": "loopInput",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        }
    ],
    "outputs": [
        {
            "name": "loopOutput",
            "type": "String | Number | Boolean | Object | Array"
        },
        {
            "name": "iterationCount",
            "type": "Number"
        }
    ],
    "configuration": {
        "doWhile": {
            "condition": "string",
            "maxIterations": "number"
        }
    }
}

Nella configurazione:

Un nodo del prompt definisce un prompt da utilizzare nel flusso. È possibile utilizzare un prompt di Gestione dei prompt o definirne uno in linea nel nodo. Per ulteriori informazioni, consulta Creare e archiviare prompt riutilizzabili con Gestione dei prompt in Amazon Bedrock.

Per vedere un esempio, consulta Provare flussi di esempio.

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

Di seguito viene illustrata la struttura generale di un oggetto FlowNode del 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),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}

L’oggetto PromptFlowNodeSourceConfiguration dipende dall’utilizzo di un prompt di Gestione dei prompt o dalla definizione in linea:

Per applicare un guardrail di Guardrail per Amazon Bedrock al tuo prompt o alla risposta che genera, includi il campo guardrailConfiguration e specifica l’ID o l’ARN del guardrail nel campo guardrailIdentifier e la versione del guardrail nel campo guardrailVersion.

Un nodo dell’agente consente di inviare un prompt a un agente, che orchestra tra FM e risorse associate per identificare ed eseguire azioni per un utente finale. Per ulteriori informazioni, consulta Automazione delle attività nella propria applicazione utilizzando agenti IA.

Nella configurazione, specifica il nome della risorsa Amazon (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.

Un nodo dell’agente può supportare invocazioni a più turni, abilitando conversazioni interattive tra gli utenti e l’agente durante l’esecuzione del flusso. Quando un nodo dell’agente richiede informazioni o chiarimenti aggiuntivi, può mettere in pausa l’esecuzione del flusso e richiedere un input specifico all’utente. Una volta che l’utente fornisce le informazioni richieste, il nodo dell’agente continua l’elaborazione con il nuovo input. Questa operazione continua finché il nodo dell’agente non dispone di tutte le informazioni necessarie per completare l’esecuzione

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

{
    "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 di Knowledge Base per Amazon Bedrock. Per ulteriori informazioni, consulta Recupero di dati e generazione di risposte di IA con Knowledge Base per Amazon Bedrock.

Nella configurazione, fornisci almeno knowledgeBaseId. È possibile includere i campi riportati di seguito, a seconda del caso d’uso:

L’input nel nodo è la query della knowledge base. L’output è la risposta del modello, sotto forma di stringa, o un array dei risultati recuperati.

Di seguito, viene illustrata la struttura generale di un oggetto FlowNode della knowledge base:

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

Un nodo di storage S3 consente di archiviare i dati nel flusso verso un bucket Amazon S3. Nella configurazione, specifichi il bucket S3 da utilizzare per l’archiviazione di 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 FlowNode di storage S3:

{
    "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 nel flusso. Nella configurazione, specifichi il bucket S3 da cui recuperare i dati. L’input nel nodo è la chiave oggetto. Il nodo restituisce il contenuto nella posizione S3 come output.

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

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

Un nodo della 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, Amazon Bedrock invia un evento di input alla funzione Lambda specificata.

Nella configurazione, specifica il nome della risorsa Amazon (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 oggetto FlowNode della funzione Lambda:

{
    "name": "string",
    "type": "LambdaFunction",
    "inputs": [
       {
            "name": "codeHookInput",
            "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

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",
        "inputs": [
            {
               "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 campo value 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, consulta Concetti Lambda nella Guida per gli sviluppatori di AWS Lambda.

Risposta Lambda per un flusso

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

Un nodo di codice inline consente di scrivere ed eseguire codice direttamente nel flusso, abilitando trasformazioni di dati, logica personalizzata e integrazioni senza utilizzare una funzione Lambda esterna. Quando includi un nodo di codice inline nel flusso, Amazon Bedrock esegue il codice in un ambiente isolato e AWS gestito che non è condiviso con nessuno e non dispone di accesso a Internet.

Nella configurazione del nodo, specifica il codice da eseguire insieme al linguaggio di programmazione (attualmente Python_3 è l’unica opzione). Definisci gli input a cui il tuo codice può accedere come variabili. Il risultato dell’ultima riga eseguita nel codice viene restituito come output del nodo.

L’esempio seguente mostra la struttura generale di un oggetto FlowNode di codice inline:

{
    "name": "string",
    "type": "InlineCode",
    "inputs": [{
            "name": "string",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [{
        "name": "response",
        "type": "String | Number | Boolean | Object | Array"
    }],
    "configuration": {
        "inlineCode": {
            "code": "string",
            "language": "Python_3"
        }
    }
}

Considerazioni su quando utilizzare i nodi di codice inline

Quando usi i nodi di codice inline nel flusso, tieni in considerazione quanto segue:

Input del nodo di codice inline

Gli input che definisci per il nodo di codice inline sono disponibili come variabili Python nel codice. Ad esempio, se definisci un input denominato userData, puoi accedervi direttamente nel codice come userData.

Il valore di ogni input viene compilato in base all’espressione definita. Ad esempio, se l’input per il nodo è {"name": "John", "age": 30} e l’espressione è $.name, il valore della variabile di input sarebbe "John".

Output del nodo di codice inline

Il risultato dell’ultima riga eseguita nel codice viene restituito come output del nodo di codice inline. Questo output è disponibile per i nodi successivi del flusso.

Ad esempio, il codice seguente restituisce un dizionario come output del nodo:

# Process input data
result = {"processed": True, "data": userData}

# The last line's result is returned as the node output
result

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 Guida per gli sviluppatori di Amazon Lex.

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

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

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