Événement d’entrée Lambda à partir d’Amazon Bedrock Événement de réponse Lambda à Amazon Bedrock Exemple de fonction Lambda d’un groupe d’actions

Configurer les fonctions Lambda pour envoyer les informations qu'un agent Amazon Bedrock obtient de l'utilisateur

Vous pouvez définir une fonction Lambda pour programmer la logique métier d'un groupe d'actions. Une fois qu'un agent Amazon Bedrock a déterminé l'opération d'API qu'il doit invoquer dans un groupe d'action, il envoie les informations du schéma d'API ainsi que les métadonnées pertinentes en tant qu'événement d'entrée à la fonction Lambda. Pour écrire votre fonction, vous devez comprendre les composants suivants de la fonction Lambda :

Événement d'entrée : contient les métadonnées pertinentes et les champs renseignés à partir du corps de la demande de l'opération d'API ou des paramètres de fonction pour l'action que l'agent détermine comme devant être appelée.
Réponse : contient les métadonnées pertinentes et les champs remplis pour le corps de réponse renvoyé par l'opération d'API ou la fonction.

Vous écrivez votre fonction Lambda pour définir comment gérer un groupe d'actions et pour personnaliser la manière dont vous souhaitez que la réponse de l'API soit renvoyée. Utilisez les variables de l’événement d’entrée pour définir vos fonctions et renvoyer une réponse à l’agent.

Note

Un groupe d'actions peut contenir jusqu'à 11 opérations d'API, mais vous ne pouvez écrire qu'une seule fonction Lambda. Étant donné que la fonction Lambda ne peut recevoir un événement d'entrée et renvoyer une réponse que pour une seule opération d'API à la fois, vous devez écrire la fonction en tenant compte des différentes opérations d'API qui peuvent être invoquées.

Pour que votre agent utilise une fonction Lambda, vous devez associer une politique basée sur les ressources à la fonction afin de fournir des autorisations à l'agent. Pour plus d'informations, suivez les étapes indiquées surPolitique basée sur les ressources permettant à Amazon Bedrock d'invoquer une fonction Lambda de groupe d'actions. Pour plus d'informations sur les politiques basées sur les ressources dans Lambda, consultez la section Utilisation des politiques basées sur les ressources pour Lambda dans le manuel du développeur. AWS Lambda

Pour savoir comment définir une fonction lors de la création du groupe d'actions, consultezAjoutez un groupe d'action à votre agent dans Amazon Bedrock.

Rubriques

Événement d’entrée Lambda à partir d’Amazon Bedrock
Événement de réponse Lambda à Amazon Bedrock
Exemple de fonction Lambda d’un groupe d’actions

Événement d’entrée Lambda à partir d’Amazon Bedrock

Lorsqu’un groupe d’actions utilisant une fonction Lambda est invoqué, Amazon Bedrock envoie un événement d’entrée Lambda au format général suivant. Vous pouvez définir votre fonction Lambda de manière à utiliser n'importe quel champ d'événement en entrée afin de manipuler la logique métier au sein de la fonction afin d'exécuter correctement l'action. Pour plus d'informations sur les fonctions Lambda, consultez la section Invocation pilotée par des événements dans le Guide du développeur. AWS Lambda

Le format d'événement d'entrée varie selon que vous avez défini le groupe d'actions avec un schéma d'API ou avec les détails des fonctions :

Si vous avez défini le groupe d'actions avec un schéma d'API, le format d'événement d'entrée est le suivant :


{
    "messageVersion": "1.0",
    "agent": {
        "name": "string",
        "id": "string",
        "alias": "string",
        "version": "string"
    },
    "inputText": "string",
    "sessionId": "string",
    "actionGroup": "string",
    "apiPath": "string",
    "httpMethod": "string",
    "parameters": [
        {
            "name": "string",
            "type": "string",
            "value": "string"
        },
    ...
    ],
    "requestBody": {
        "content": {
            "<content_type>": {
                "properties": [
                   {
                       "name": "string",
                       "type": "string",
                       "value": "string"
                    },
                            ...
                ]
            }
        }
    },
    "sessionAttributes": {
        "string": "string",
    },
    "promptSessionAttributes": {
        "string": "string"
    }
}

Si vous avez défini le groupe d'actions avec les détails de la fonction, le format de l'événement d'entrée est le suivant :


{
    "messageVersion": "1.0",
    "agent": {
        "name": "string",
        "id": "string",
        "alias": "string",
        "version": "string"
    },
    "inputText": "string",
    "sessionId": "string",
    "actionGroup": "string",
    "function": "string",
    "parameters": [
        {
            "name": "string",
            "type": "string",
            "value": "string"
        },
    ...
    ],
    "sessionAttributes": {
        "string": "string",
    },
    "promptSessionAttributes": {
        "string": "string"
    }
}

La liste suivante décrit les champs d'événements en entrée ;

messageVersion : version du message identifiant le format des données d’événement entrant dans la fonction Lambda, et format attendu de la réponse provenant d’une fonction Lambda. Amazon Bedrock ne prend en charge que la version 1.0.
agent : contient des informations sur le nom, l’ID, l’alias et la version de l’agent auquel appartient le groupe d’actions.
inputText : entrée utilisateur pour le tour de conversation.
sessionId : identifiant unique de la session de l’agent.
actionGroup : nom du groupe d’actions.
parameters : contient une liste d’objets. Chaque objet contient le nom, le type et la valeur d'un paramètre de l'opération d'API, tel que défini dans le OpenAPI schéma, ou dans la fonction.
Si vous avez défini le groupe d'actions avec un schéma d'API, l'événement d'entrée contient les champs suivants :
- apiPath— Le chemin d'accès à l'opération d'API, tel que défini dans le OpenAPI schéma.
- httpMethod— La méthode de fonctionnement de l'API, telle que définie dans le OpenAPI schéma.
- requestBody— Contient le corps de la demande et ses propriétés, tels que définis dans le OpenAPI schéma du groupe d'actions.
Si vous avez défini le groupe d'actions avec les détails de la fonction, l'événement d'entrée contient le champ suivant :
- function— Le nom de la fonction tel que défini dans les détails de la fonction pour le groupe d'actions.
sessionAttributes— Contient les attributs de session et leurs valeurs. Ces attributs sont stockés au cours d'une session et fournissent un contexte à l'agent.
promptSessionAttributes— Contient les attributs de session d'invite et leurs valeurs. Ces attributs sont stockés au fil d'un tour et fournissent un contexte à l'agent.

Événement de réponse Lambda à Amazon Bedrock

Amazon Bedrock attend une réponse d’une fonction Lambda correspondant au format suivant. La réponse consiste en des paramètres renvoyés par l'opération d'API. L’agent peut utiliser la réponse de la fonction Lambda pour une orchestration plus poussée ou pour l’aider à renvoyer une réponse au client.

Note

La taille maximale de réponse de la charge utile Lambda est de 25 Ko.

Le format d'événement d'entrée varie selon que vous avez défini le groupe d'actions avec un schéma d'API ou avec les détails des fonctions :

Si vous avez défini le groupe d'actions avec un schéma d'API, le format de réponse est le suivant :


{
    "messageVersion": "1.0",
    "response": {
        "actionGroup": "string",
        "apiPath": "string",
        "httpMethod": "string",
        "httpStatusCode": number,
        "responseBody": {
            "<contentType>": {
                "body": "JSON-formatted string" 
            }
        }
    },
    "sessionAttributes": {
        "string": "string",
        ...
    },
    "promptSessionAttributes": {
        "string": "string",
        ...
    },
    "knowledgeBasesConfiguration": [
        {
            "knowledgeBaseId": "string",
            "retrievalConfiguration": {
                "vectorSearchConfiguration": {
                    "numberOfResults": int,
                    "overrideSearchType": "HYBRID | SEMANTIC",
                    "filter": RetrievalFilter object
                }
            }
        },
        ...
    ]
}

Si vous avez défini le groupe d'actions avec les détails de la fonction, le format de réponse est le suivant :


{
    "messageVersion": "1.0",
    "response": {
        "actionGroup": "string",
        "function": "string",
        "functionResponse": {
            "responseState": "FAILURE | REPROMPT",
            "responseBody": {
                "<functionContentType>": { 
                    "body": "JSON-formatted string"
                }
            }
        }
    },
    "sessionAttributes": {
        "string": "string",
    },
    "promptSessionAttributes": {
        "string": "string"
    },
    "knowledgeBasesConfiguration": [
        {
            "knowledgeBaseId": "string",
            "retrievalConfiguration": {
                "vectorSearchConfiguration": {
                    "numberOfResults": int,
                    "filter": {
                        RetrievalFilter object
                    }
                }
            }
        },
        ...
    ]
}

La liste suivante décrit les champs de réponse :

messageVersion : version du message identifiant le format des données d’événement entrant dans la fonction Lambda, et format attendu de la réponse provenant d’une fonction Lambda. Amazon Bedrock ne prend en charge que la version 1.0.
response : contient les informations suivantes sur la réponse de l’API.
- actionGroup : nom du groupe d’actions.
- Si vous avez défini le groupe d'actions avec un schéma d'API, les champs suivants peuvent figurer dans la réponse :
  - apiPath— Le chemin d'accès à l'opération d'API, tel que défini dans le OpenAPI schéma.
  - httpMethod— La méthode de fonctionnement de l'API, telle que définie dans le OpenAPI schéma.
  - httpStatusCode— Le code d'état HTTP renvoyé par l'opération d'API.
  - responseBody— Contient le corps de la réponse, tel que défini dans le OpenAPI schéma.
- Si vous avez défini le groupe d'actions avec les détails de la fonction, les champs suivants peuvent figurer dans la réponse :
  - responseState(Facultatif) — Définissez l'un des états suivants pour définir le comportement de l'agent après le traitement de l'action :
    
    ÉCHEC — L'agent lance un message DependencyFailedException pour la session en cours. S'applique lorsque l'exécution de la fonction échoue en raison d'une défaillance de dépendance.
    
    REPROMPT — L'agent transmet une chaîne de réponse au modèle pour le réinviter. S'applique lorsque l'exécution de la fonction échoue en raison d'une entrée non valide.
  - responseBody— Contient un objet qui définit la réponse suite à l'exécution de la fonction. La clé est le type de contenu (actuellement seul TEXT est pris en charge) et la valeur est un objet contenant body la réponse.
(Facultatif) sessionAttributes : contient les attributs de session et leurs valeurs. Pour de plus amples informations, veuillez consulter Attributs de session et de session d'invite.
(Facultatif) promptSessionAttributes : contient les attributs d’invite et leurs valeurs. Pour de plus amples informations, veuillez consulter Attributs de session et de session d'invite.
(Facultatif) knowledgeBasesConfiguration — Contient une liste de configurations de requêtes pour les bases de connaissances associées à l'agent. Pour de plus amples informations, veuillez consulter Configurations de récupération de la base de connaissances.

Exemple de fonction Lambda d’un groupe d’actions

Voici un exemple minimal de la façon dont la fonction Lambda peut être définie dans Python. Sélectionnez l'onglet correspondant à la définition du groupe d'actions avec un OpenAPI schéma ou avec les détails de la fonction :

OpenAPI schema


def lambda_handler(event, context):

    agent = event['agent']
    actionGroup = event['actionGroup']
    api_path = event['apiPath']
    # get parameters
    get_parameters = event.get('parameters', [])
    # post parameters
    post_parameters = event['requestBody']['content']['application/json']['properties']

    response_body = {
        'application/json': {
            'body': "sample response"
        }
    }
    
    action_response = {
        'actionGroup': event['actionGroup'],
        'apiPath': event['apiPath'],
        'httpMethod': event['httpMethod'],
        'httpStatusCode': 200,
        'responseBody': response_body
    }
    
    session_attributes = event['sessionAttributes']
    prompt_session_attributes = event['promptSessionAttributes']
    
    api_response = {
        'messageVersion': '1.0', 
        'response': action_response,
        'sessionAttributes': session_attributes,
        'promptSessionAttributes': prompt_session_attributes
    }
        
    return api_response

Function details


def lambda_handler(event, context):

    agent = event['agent']
    actionGroup = event['actionGroup']
    function = event['function']
    parameters = event.get('parameters', [])

    response_body = {
        'TEXT': {
            'body': "sample response"
        }
    }
    
    function_response = {
        'actionGroup': event['actionGroup'],
        'function': event['function'],
        'functionResponse': {
            'responseBody': response_body
        }
    }
    
    session_attributes = event['sessionAttributes']
    prompt_session_attributes = event['promptSessionAttributes']
    
    action_response = {
        'messageVersion': '1.0', 
        'response': function_response,
        'sessionAttributes': session_attributes,
        'promptSessionAttributes': prompt_session_attributes
    }
        
    return action_response

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Gérer l'exécution de l'action

Redonnez le contrôle au développeur de l'agent