Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Fonctionnement d’Amazon Bedrock Flows
<a name="flows-how-it-works"></a>

Amazon Bedrock Flows vous permet de créer des flux de travail d’IA générative en connectant des nœuds, chacun correspondant à une étape du flux qui invoque une ressource Amazon Bedrock ou associée. Pour définir les entrées et les sorties des nœuds, vous spécifiez la manière dont les entrées sont interprétées à l’aide d’expressions. Pour mieux comprendre ces concepts, consultez les rubriques suivantes :

**Topics**
+ [

# Définitions clés pour Amazon Bedrock Flows
](key-definitions-flow.md)
+ [

# Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock Flows
](flows-expressions.md)
+ [

# Types de nœuds pour votre flux
](flows-nodes.md)

# Définitions clés pour Amazon Bedrock Flows
<a name="key-definitions-flow"></a>

La liste suivante présente les concepts de base d’Amazon Bedrock Flows.
+ **Flux** : un flux est une construction composée d’un nom, d’une description, d’autorisations, d’un ensemble de nœuds et de connexions entre les nœuds. Lorsqu’un flux est invoqué, l’entrée de l’invocation est envoyée via chaque nœud du flux jusqu’à ce qu’un nœud de sortie soit atteint. La réponse à l’invocation renvoie le résultat final.
+ **Nœud** : un nœud est une étape à l’intérieur d’un flux. Pour chaque nœud, vous configurez son nom, sa description, son entrée, sa sortie et toute autre configuration supplémentaire. La configuration d’un nœud varie en fonction de son type. Pour en savoir plus sur les types de nœuds, consultez [Types de nœuds pour votre flux](flows-nodes.md).
+ **Connexion** : deux types de connexions sont utilisés dans Amazon Bedrock Flows :
  + Une **connexion de données** est établie entre la sortie d’un nœud (le *nœud source*) et l’entrée d’un autre nœud (le *nœud cible*) et elle envoie des données d’un nœud en amont à un nœud en aval. Dans le volet de la console Amazon Bedrock, les connexions de données sont représentées par des lignes grises continues.
  + Une **connexion conditionnelle** est établie entre une condition dans un nœud de condition et un nœud en aval et envoie des données du nœud qui précède le nœud de condition à un nœud en aval si la condition est remplie. Dans la console Amazon Bedrock, les connexions conditionnelles sont représentées par des lignes violettes tiretées.
+ **Expressions** : une expression définit comment extraire une entrée de l’ensemble des entrées entrant dans un nœud. Pour savoir comment écrire des expressions, consultez [Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock FlowsDéfinition d’entrées avec des expressions](flows-expressions.md).
+ **Générateur de flux** : le générateur de flux est un outil de la console Amazon Bedrock permettant de créer et de modifier des flux via une interface visuelle. Vous utilisez l’interface visuelle pour glisser-déposer des nœuds sur l’interface et configurer les entrées et les sorties de ces nœuds afin de définir votre flux.
+ Dans les sections suivantes, nous utiliserons les termes suivants :
  + **Entrée complète** : entrée complète envoyée du nœud précédent au nœud actuel.
  + **En amont** : fait référence aux nœuds qui apparaissent plus tôt dans le flux.
  + **En aval** : fait référence aux nœuds qui apparaissent plus tard dans le flux.
  + **Entrée** : un nœud peut avoir plusieurs entrées. Vous utilisez des expressions pour extraire les parties pertinentes de l’ensemble de l’entrée à utiliser pour chaque entrée individuelle. Dans le créateur de flux de la console Amazon Bedrock, une entrée apparaît sous la forme d’un cercle sur la périphérie gauche d’un nœud. Connectez chaque entrée à la sortie appropriée à partir d’un nœud en amont.
  + **Sortie** : un nœud peut avoir plusieurs sorties. Dans le créateur de flux de la console Amazon Bedrock, une sortie apparaît sous la forme d’un cercle sur la périphérie droite d’un nœud. Connectez chaque sortie à au moins une entrée d’un nœud en aval.
  + **Branche** : si une sortie d’un nœud est envoyée à plusieurs nœuds, ou si un nœud conditionnel est inclus, le chemin d’un flux sera divisé en plusieurs branches. Chaque branche peut potentiellement générer une autre sortie dans la réponse d’invocation du flux.

# Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock Flows
<a name="flows-expressions"></a>

Lorsque vous configurez les entrées d’un nœud, vous devez les définir par rapport à l’intégralité de l’entrée saisie dans le nœud. L’intégralité de l’entrée peut être une chaîne, un nombre, une valeur booléenne, un tableau ou un objet. Pour définir une entrée par rapport à l’intégralité de l’entrée, vous devez utiliser un sous-ensemble d’expressions prises en charge basées sur [JsonPath](https://github.com/json-path/JsonPath). Chaque expression doit commencer par `$.data`, ce qui fait référence à l’intégralité de l’entrée. Notez les points suivants concernant l’utilisation d’expressions :
+ Si l’intégralité de l’entrée est une chaîne, un nombre ou une valeur booléenne, la seule expression vous permettant de définir une entrée individuelle est `$.data`.
+ Si l’intégralité de l’entrée est un tableau ou un objet, vous pouvez définir une entrée individuelle à l’aide de l’extraction d’une partie de celui-ci.

À titre d’exemple, pour comprendre comment utiliser des expressions, supposons que l’intégralité de l’entrée est l’objet JSON suivant :

```
{
    "animals": {
        "mammals": ["cat", "dog"],
        "reptiles": ["snake", "turtle", "iguana"]
    },
    "organisms": {
        "mammals": ["rabbit", "horse", "mouse"],
        "flowers": ["lily", "daisy"]
    },
    "numbers": [1, 2, 3, 5, 8]
}
```

Vous pouvez extraire une partie de l’entrée à l’aide des expressions suivantes (Les exemples font référence à ce qui serait renvoyé par l’objet JSON précédent.) :


****  

| Expression | Signification | Exemple | Exemple de résultat | 
| --- | --- | --- | --- | 
| \$1.data | L’intégralité de l’entrée. | \$1.data | L’intégralité de l’objet. | 
| .name | Valeur d’un champ nommé name dans un objet JSON. | \$1.data.numbers | [1, 2, 3, 5, 8] | 
| [int] | Membre à l’index spécifié par int dans un tableau. | \$1.data.animals.reptiles[2] | iguane | 
| [int1, int2, ...] | Membres aux indices spécifiés par chaque valeur int dans un tableau. | \$1.data.numbers[0, 3] | [1, 5] | 
| [int1:int2] | Tableau composé des éléments aux indices compris entre int1 (inclusif) et int2 (exclusif) dans un tableau. L’omission d’int1 ou int2 équivaut à marquer le début ou la fin du tableau. | \$1.data.organisms.mammals[1:] | [« cheval », « souris »] | 
| \$1 | Caractère générique utilisable à la place d’une valeur name ou int. S’il existe plusieurs résultats, ils sont renvoyés sous forme de tableau. | \$1.data.\$1.mammals | [[« chat », « chien »], [« lapin », « cheval », « souris »]] | 

# Types de nœuds pour votre flux
<a name="flows-nodes"></a>

Amazon Bedrock Flows fournit les types de nœuds suivants pour créer votre flux. Lorsque vous configurez un nœud, vous devez fournir les champs suivants :
+ Nom : saisissez un nom pour le nœud.
+ Type : dans la console, vous devez glisser-déposer le type de nœud à utiliser. Dans l'API, utilisez le `type` champ et [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)le `configuration` champ correspondant.
+ Entrées : renseignez les informations suivantes pour chaque entrée :
  + Nom : nom de l’entrée. Certains nœuds ont des noms ou types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, consultez [Types de nœuds logiques](#flows-nodes-logic-table).
  + Expression : définissez la partie de l’ensemble de l’entrée à utiliser comme entrée individuelle. Pour de plus amples informations, veuillez consulter [Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock FlowsDéfinition d’entrées avec des expressions](flows-expressions.md).
  + Type : type de données de l’entrée. Lorsque ce nœud est atteint lors de l’exécution, Amazon Bedrock applique l’expression à l’ensemble de l’entrée et vérifie que le résultat correspond au type de données.
+ Sorties : renseignez les informations suivantes pour chaque sortie :
  + Nom : nom de la sortie. Certains nœuds ont des noms ou types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, consultez [Types de nœuds logiques](#flows-nodes-logic-table).
  + Type : type de données de la sortie. Lorsque ce nœud est atteint lors de l’exécution, Amazon Bedrock vérifie que la sortie du nœud correspond au type de données.
+ Configuration : dans la console, vous définissez des champs spécifiques au nœud en haut du nœud. Dans l'API, utilisez le code approprié [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)et renseignez ses champs.

Chaque type de nœud est décrit ci-dessous et sa structure dans l’API est fournie. Développez une section pour en savoir plus sur ce type de nœud.

## Nœuds permettant de contrôler la logique de flux
<a name="flows-nodes-logic"></a>

Contrôlez la logique de votre flux à l’aide des types de nœuds suivants.

### Nœud d’entrée de flux
<a name="flows-nodes-input"></a>

Chaque flux ne contient qu’un seul nœud d’entrée de flux et doit commencer par celui-ci. Le nœud d’entrée de flux prend le `content` de la demande `InvokeFlow`, vérifie le type de données et l’envoie au nœud suivant.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet d'entrée dans l'API :

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

### Nœud de sortie de flux
<a name="flows-nodes-output"></a>

Un nœud de sortie de flux extrait les données d’entrée du nœud précédent, en fonction de l’expression définie, et les renvoie. Dans la console, la sortie est la réponse renvoyée après un clic sur **Exécuter** dans la fenêtre de test. Dans l’API, la sortie est renvoyée dans le champ `content` de l’`flowOutputEvent` de la réponse `InvokeFlow`. Un flux peut comporter plusieurs nœuds de sortie de flux.

Un flux peut comporter plusieurs nœuds de sortie de flux s’il compte plusieurs branches.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de sortie :

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

### Nœud de condition
<a name="flows-nodes-condition"></a>

Un nœud de condition envoie des données du nœud précédent à différents nœuds, en fonction des conditions définies. Un nœud de condition peut accepter plusieurs entrées.

Pour obtenir un exemple, consultez [Création d’un flux avec un nœud de condition](flows-ex-condition.md).

**Pour définir un nœud de condition**

1. Ajoutez autant d’entrées que nécessaire pour évaluer les conditions que vous prévoyez d’ajouter.

1. Saisissez un nom pour chaque entrée, spécifiez le type attendu et écrivez une expression pour extraire la partie pertinente de l’ensemble de l’entrée.

1. Connectez chaque entrée à la sortie appropriée à partir d’un nœud en amont.

1. Ajoutez autant de conditions que nécessaire.

1. Pour chaque condition :

   1. Saisissez un nom pour la condition.

   1. Définissez une condition qui compare les entrées à d’autres ou à une constante à l’aide d’opérateurs relationnels et logiques.
**Note**  
Les conditions sont évaluées dans l’ordre. Si plusieurs conditions sont remplies, la première prévaut.

   1. Connectez chaque condition au nœud en aval auquel vous souhaitez envoyer les données si la condition concernée est remplie.

#### Expressions conditionnelles
<a name="flows-nodes-condition-expr"></a>

Pour définir une condition, vous devez faire référence à une entrée par son nom et la comparer à une valeur à l’aide de l’un des opérateurs relationnels suivants :


****  

| Opérateur | Signification | Types de données pris en charge | Exemple d’utilisation | Signification de l’exemple | 
| --- | --- | --- | --- | --- | 
| == | Égal à (Le type de données doit également être égal.) | Chaîne, Nombre, Booléen | A == B | Si A est égal à B | 
| \$1= | Non égal à | Chaîne, Nombre, Booléen | A \$1= B | Si A n’est pas égal à B | 
| > | Supérieur à | Number | A > B | Si A est supérieur à B | 
| >= | Supérieur ou égal à | Number | A >= B | Si A est supérieur ou égal à B | 
| < | Inférieur à | Number | A < B | Si A est inférieur à B | 
| <= | Inférieur ou égal à | Number | A <= B | Si A est inférieur ou égal à B | 

Vous pouvez comparer les entrées à d’autres ou à une constante dans une expression conditionnelle. Par exemple, si vous avez une entrée numérique nommée `profit` et une autre nommée `expenses`, **profit > expenses** et **profit <= 1000** sont des expressions valides.

Vous pouvez combiner des expressions correspondant à des conditions plus complexes à l’aide des opérateurs logiques suivants. Nous vous recommandons de résoudre les ambiguïtés liées au regroupement d’expressions à l’aide de parenthèses :


****  

| Opérateur | Signification | Exemple d’utilisation | Signification de l’exemple | 
| --- | --- | --- | --- | 
| and | Les deux expressions ont la valeur true | (A < B) and (C == 1) | Si les deux expressions ont la valeur true : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html) | 
| or | Au moins une expression a la valeur true | (A \$1= 2) or (B > C) | Si l’une des expressions a la valeur true : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html) | 
| not | L’expression n’a pas la valeur true | not (A > B) | Si A n’est pas supérieur à B (équivalent à A <= B) | 

Dans l'API, vous définissez les éléments suivants dans le `definition` champ lorsque vous envoyez une [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)or :

1. Un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de condition dans le `nodes` tableau. Voici e format général (Notez que les nœuds conditionnels n’ont pas de `outputs`) :

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

1. Pour chaque entrée dans le nœud de condition, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet dans le `connections` tableau. Incluez un [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)objet dans le `configuration` champ de l'`FlowConnection`objet. Voici le format général de l’objet `FlowConnection` :

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

1. Pour chaque condition (y compris la condition par défaut) du nœud de condition, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet du `connections` tableau. Incluez un [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)objet dans le `configuration` champ de l'`FlowConnection`objet. Le format général de l'[FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet est le suivant :

   ```
   {
       "name": "string",
       "source": "string",
       "target": "string",
       "type": "Conditional",
       "configuration": {
           "conditional": {
               "condition": "string"
           }
       }
   }
   ```

   Définissez la `condition` qui connecte ce nœud `source` conditionnel à un nœud `target` en aval à l’aide d’opérateurs relationnels et logiques. Pour la condition par défaut, spécifiez la condition sous la forme **default**.

### Nœuds itérateurs
<a name="flows-nodes-iterator"></a>

Un nœud itérateur prend un tableau et renvoie itérativement ses éléments en sortie au nœud en aval. Les entrées du nœud itérateur sont traitées une par une et non en parallèle les unes avec les autres. Le nœud de sortie de flux renvoie le résultat final pour chaque entrée dans une réponse différente. Vous pouvez également recueillir les réponses itérées à l’aide d’un nœud collecteur en aval du nœud itérateur et les renvoyer sous forme de tableau, en sus de la taille du tableau.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet itérateur :

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

### Nœud collecteur
<a name="flows-nodes-collector"></a>

Un nœud collecteur prend une entrée itérée, en sus de la taille du tableau, et les renvoie sous forme de tableau. Vous pouvez recueillir les éléments itérés à l’aide d’un nœud collecteur en aval d’un nœud itérateur après les avoir envoyés au moyen de certains nœuds.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de collection :

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

### DoWhile nœud en boucle
<a name="flows-nodes-dowhile"></a>

Un nœud DoWhile en boucle exécute une séquence de nœuds à plusieurs reprises tant qu'une condition spécifiée reste vraie. La boucle s’exécute au moins une fois avant d’évaluer la condition, ce qui la rend idéale pour les scénarios dans lesquels vous devez effectuer une action, puis vérifier si elle doit être répétée en fonction du résultat.

Le nœud de DoWhile boucle prend les données d'entrée et les fait passer par le corps de la boucle. Après chaque itération, la condition est évaluée pour déterminer s’il convient de poursuivre la boucle ou d’y mettre fin. La boucle continue tant que la condition est remplie ou que le `maxIterations` n’est pas dépassé.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet DoWhile en boucle :

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

Dans la configuration :
+ `condition` : expression booléenne qui détermine s’il convient de poursuivre la boucle. Utilisez les mêmes opérateurs relationnels et logiques que ceux des nœuds conditionnels. La condition est évaluée après chaque itération.
+ `maxIterations` : nombre maximal d’itérations. La valeur par défaut est 10. Vous devez spécifier un nombre positif. Ce paramètre vous permet d’éviter les boucles infinies.

**Note**  
Le paramètre `maxIterations` a une valeur par défaut de 10 et n’accepte que des nombres positifs. La boucle se termine lorsque la condition n’est plus remplie ou lorsque le nombre maximal d’itérations est atteint.

## Nœuds dédiés à la gestion des données dans le flux
<a name="flows-nodes-data"></a>

Gérez les données de votre flux à l’aide des types de nœuds suivants :

### Nœud d’invite
<a name="flows-nodes-prompt"></a>

Un nœud d’invite définit une invite à utiliser dans le flux. Vous pouvez utiliser une invite de Prompt Management ou en définir une en ligne dans le nœud. Pour de plus amples informations, veuillez consulter [Création et stockage d’invites réutilisables avec la gestion des invites dans Amazon Bedrock](prompt-management.md).

Pour obtenir un exemple, consultez [Test d’exemples de flux](flows-ex.md).

Les entrées du nœud d’invite sont des valeurs permettant de renseigner les variables. La sortie est la réponse générée par le modèle.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet d'invite :

```
{
    "name": "string",
    "type": "prompt",
    "inputs": [
        {
            "name": "content",
            "type": "String | Number | Boolean | Object | Array",
            "expression": "string"
        },
        ...
    ],
    "outputs": [
        {
            "name": "modelCompletion",
            "type": "String"
        }
    ],
    "configuration": {
        "prompt": {
            "sourceConfiguration": [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html) object (see below),
            "guardrailConfiguration": {
                "guardrailIdentifier": "string",
                "guardrailVersion": "string"
            }
        }
    }
}
```

L'[PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)objet varie selon que vous utilisez une invite de la gestion des invites ou que vous la définissez en ligne :
+ Si vous utilisez une invite de Prompt Management, l’objet doit présenter la structure générale suivante :

  ```
  {
      "resource": {
          "promptArn": "string"
      }
  }
  ```
+ Si vous définissez une invite inline, suivez les instructions pour définir une variante dans l’onglet API de [Création d’une invite à l’aide de la gestion des invites](prompt-management-create.md). (Notez toutefois que cet objet ne comporte aucun champ `name`.) L’objet que vous utilisez doit présenter la structure générale suivante :

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

Pour appliquer une barrière de protection Amazon Bedrock à votre invite ou à la réponse générée depuis celui-ci, incluez le champ `guardrailConfiguration` et spécifiez l’identifiant ou l’ARN de la barrière de protection dans le champ `guardrailIdentifier` et la version de la barrière de protection dans le champ `guardrailVersion`.

### Nœud d’agent
<a name="flows-nodes-agent"></a>

Un nœud d'agent vous permet d'envoyer une invite à un agent, qui orchestre les ressources associées entre FMs elles afin d'identifier et d'exécuter des actions pour un utilisateur final. Pour de plus amples informations, veuillez consulter [Automatisation des tâches de votre application à l’aide d’agents d’IA](agents.md).

Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de l’alias de l’agent à utiliser. Les entrées dans le nœud sont l’invite pour l’agent et tout [attribut d’invite ou de session](agents-session-state.md) associé. Le nœud renvoie la réponse de l’agent sous forme de sortie.

Un nœud d’agent peut prendre en charge les invocations à plusieurs tours, permettant ainsi des conversations interactives entre les utilisateurs et l’agent pendant l’exécution du flux. Lorsqu’un nœud d’agent a besoin d’informations ou de précisions supplémentaires, il peut suspendre l’exécution du flux et demander des entrées spécifiques à l’utilisateur. Une fois que l’utilisateur a fourni les informations demandées, le nœud d’agent poursuit son traitement avec la nouvelle entrée. Cela continue jusqu’à ce que le nœud d’agent dispose de toutes les informations requises pour terminer son exécution.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet agent :

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

### Nœud de base de connaissances
<a name="flows-nodes-kb"></a>

Un nœud de base de connaissances vous permet d’envoyer une requête à une base de connaissances à partir d’Amazon Bedrock Knowledge Bases. Pour de plus amples informations, veuillez consulter [Récupération de données et génération de réponses basées sur l’IA avec Amazon Bedrock Knowledge Bases](knowledge-base.md).

Dans la configuration, indiquez au minimum l’`knowledgeBaseId`. Vous pouvez éventuellement inclure les champs suivants en fonction de votre cas d’utilisation :
+ `modelId` : incluez un [ID de modèle](models-supported.md) à utiliser si vous souhaitez générer une réponse basée sur les résultats récupérés. Pour renvoyer les résultats récupérés sous forme de tableau, omettez l’ID du modèle.
+ `guardrailConfiguration` : incluez l’identifiant ou l’ARN de la barrière de protection, défini dans les barrières de protection Amazon Bedrock, dans le champ `guardrailIdentifier` et la version de la barrière de protection dans le champ `guardrailVersion`.
**Note**  
Les barrières de protection peuvent être appliquées uniquement en cas d’utilisation de `RetrieveAndGenerate` dans un nœud de base de connaissances.

L’entrée dans le nœud est la requête envoyée à la base de connaissances. La sortie est soit la réponse du modèle, sous forme de chaîne, soit un tableau des résultats récupérés.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de base de connaissances :

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

### Nœud de stockage S3
<a name="flows-nodes-storage"></a>

Un nœud de stockage S3 vous permet de stocker des données dans le flux vers un compartiment Amazon S3. Dans la configuration, vous spécifiez le compartiment S3 à utiliser pour le stockage de données. Les entrées dans le nœud sont le contenu à stocker et la [clé de l’objet](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Le nœud renvoie l’URI de l’emplacement S3 en sortie.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de stockage 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"
                }
            }
        }
    }
}
```

### Nœud de récupération S3
<a name="flows-nodes-retrieval"></a>

Un nœud de récupération S3 vous permet de récupérer des données depuis un emplacement Amazon S3 pour les introduire dans le flux. Dans la configuration, vous spécifiez le compartiment S3 à partir duquel vous souhaitez récupérer les données. L’entrée dans le nœud est la [clé de l’objet](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Le nœud renvoie le contenu de l’emplacement S3 en sortie.

**Note**  
À l’heure actuelle, les données de l’emplacement S3 doivent être une chaîne codée en UTF-8.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de récupération S3 :

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

### Nœud de fonction Lambda
<a name="flows-nodes-lambda"></a>

Un nœud de fonction Lambda vous permet d’appeler une fonction Lambda dans laquelle vous pouvez définir du code pour exécuter une logique métier. Lorsque vous incluez un nœud Lambda dans un flux, Amazon Bedrock envoie un événement d’entrée à la fonction Lambda que vous spécifiez.

Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de la fonction Lambda. Définissez les entrées à envoyer dans l’événement d’entrée Lambda. Vous pouvez écrire du code en fonction de ces entrées et définir ce que la fonction renvoie. La réponse de la fonction est renvoyée dans la sortie.

Voici la structure générale d'un objet de fonction [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)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"
        }
    }
}
```

#### Événement d’entrée Lambda pour un flux
<a name="flows-nodes-lambda-input"></a>

L’événement d’entrée envoyé à une fonction Lambda dans un nœud Lambda est au format suivant :

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

Les champs de chaque entrée correspondent aux champs que vous spécifiez lors de la définition du nœud Lambda, tandis que la valeur du champ `value` est renseignée avec l’intégralité de l’entrée dans le nœud après avoir été résolue par l’expression. Par exemple, si la totalité de l’entrée du nœud est `[1, 2, 3]` et que l’expression est `$.data[1]`, la valeur envoyée dans l’événement d’entrée à la fonction Lambda est `2`.

Pour plus d’informations sur les événements dans Lambda, consultez [Concepts Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) dans le [Guide du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).

#### Réponse Lambda pour un flux
<a name="flows-nodes-lambda-response"></a>

Lorsque vous écrivez une fonction Lambda, vous définissez la réponse renvoyée par celle-ci. Cette réponse est renvoyée à votre flux en tant que sortie du nœud Lambda.

### Nœud de code inline
<a name="flows-nodes-inline-code"></a>

Un nœud de code inline vous permet d’écrire et d’exécuter du code directement dans votre flux, ce qui permet des transformations de données, une logique personnalisée et des intégrations sans utiliser de fonction Lambda externe. Lorsque vous incluez un nœud de code intégré dans votre flux, Amazon Bedrock exécute votre code dans un environnement AWS géré isolé qui n'est partagé avec personne et qui n'a pas accès à Internet.

**Note**  
La fonctionnalité de nœud de code inline est actuellement disponible en version préliminaire pour Amazon Bedrock et susceptible d’être modifiée.

Dans la configuration du nœud, spécifiez le code à exécuter et le langage de programmation. (`Python_3` est actuellement la seule option.) Définissez les entrées auxquelles votre code peut accéder en tant que variables. Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que sortie du nœud.

L'exemple suivant montre la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de code en ligne :

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

#### Éléments à prendre en compte en cas d’utilisation de nœuds de code inline
<a name="flows-nodes-inline-code-usage"></a>

Lorsque vous utilisez des nœuds de code inline dans votre flux, tenez compte des éléments suivants :

**Important**  
Nous vous recommandons de tester votre code avant de l’ajouter à un nœud de code inline.
+ Les nœuds de code inline ne sont pas pris en charge dans l’[exécution de flux asynchrones](flows-create-async.md).
+ À l’heure actuelle, le seul langage de programmation pris en charge par les nœuds de code inline est Python 3.12 (`Python_3)`.
+ Le code inline fait office de session Python interactive. Seul le résultat de la dernière ligne exécutée est capturé et renvoyé en tant que sortie du nœud.
+ La sortie de la console Python (comme celle de la fonction `print`) n’est pas capturée.
+ Les entrées pour votre nœud de code inline sont disponibles sous forme de variables Python dans votre code. Utilisez le nom exact de l’entrée du nœud pour les référencer.
+ Configurez correctement les types d’entrées et de sorties pour éviter les erreurs d’exécution. Vous pouvez configurer jusqu’à cinq entrées de nœud.
+ Vous pouvez avoir jusqu’à cinq nœuds de code inline par flux.
+ Vous pouvez avoir un maximum de 25 nœuds de code inline en cours d’exécution par Compte AWS.
+ Votre code ne doit pas dépasser 5 Mo.

#### Entrées de nœud de code inline
<a name="flows-nodes-inline-code-input"></a>

Les entrées que vous définissez pour un nœud de code inline sont disponibles sous forme de variables Python dans votre code. Par exemple, si vous définissez une entrée nommée `userData`, vous pouvez y accéder directement dans votre code en tant que `userData`.

La valeur de chaque entrée est renseignée en fonction de l’expression que vous définissez. Par exemple, si l’entrée du nœud est `{"name": "John", "age": 30}` et que l’expression est `$.name`, la valeur de la variable d’entrée est `"John"`.

#### Sortie de nœud de code inline
<a name="flows-nodes-inline-code-output"></a>

Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que nœud de code inline. Cette sortie est disponible pour les nœuds suivants de votre flux.

Par exemple, le code suivant renvoie un dictionnaire comme sortie du nœud :

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

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

### Nœud Lex
<a name="flows-nodes-lex"></a>

**Note**  
Le nœud Lex repose sur le service Amazon Lex, qui peut stocker et utiliser le contenu des clients pour le développement et l'amélioration continue d'autres AWS services. En tant que AWS client, vous pouvez refuser que votre contenu soit stocké ou utilisé pour améliorer le service. Pour découvrir comment implémenter une stratégie de désactivation pour Amazon Lex, consultez [Stratégies de désactivation des services d’IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).

Un nœud Lex vous permet d’appeler un bot Amazon Lex pour traiter un énoncé à l’aide du traitement du langage naturel et identifier une intention, en fonction de la définition du bot. Pour plus d’informations, consultez le [Guide du développeur Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).

Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de l’alias du bot à utiliser et les paramètres régionaux à utiliser. Les entrées dans le nœud sont l’énoncé et tous les [attributs de demande](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) ou [attributs de session](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) qui l’accompagnent. Le nœud renvoie l’intention identifiée en sortie.

**Note**  
À l’heure actuelle, le nœud Lex ne prend pas en charge les conversations à plusieurs tours. Un nœud Lex ne peut traiter qu’un seul énoncé.

Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet 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"
        }
    }
}
```

## Tableaux récapitulatifs pour les types de nœuds
<a name="flows-nodes-summary-table"></a>

Les tableaux suivants récapitulent les entrées et sorties autorisées pour chaque type de nœud. Notez ce qui suit :
+ Si un nom est marqué comme **N’importe lequel**, vous pouvez fournir toute chaîne comme nom. Sinon, vous devez utilisez la valeur spécifiée dans le tableau.
+ Si un type est marqué comme **N’importe lequel**, vous pouvez spécifier l’un des types de données suivants : Chaîne, Nombre, Booléen, Objet, Tableau. Sinon, vous devez utilisez le type spécifié dans le tableau.
+ Vous pouvez définir plusieurs entrées pour les nœuds **Condition**, **Invite**, **Fonction Lambda** et **Code inline**.


**Types de nœuds logiques**  
<a name="flows-nodes-logic-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html)


**Types de nœuds de traitement des données**  
<a name="flows-nodes-data-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html)