É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

Configuration de 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’actions, 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 renseignés pour le corps de réponse renvoyé par l’opération d’API ou la fonction.

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

Note

Un groupe d’actions peut contenir jusqu’à 11 opérations d’API, mais vous ne pouvez écrire qu’une seule fonction Lambda. Comme 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.

Afin que votre agent utilise une fonction Lambda, vous devez attacher 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 sous Politique 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 des ressources dans Lambda, consultez Utilisation de politiques basées sur les ressources pour Lambda dans le Guide du développeur AWS Lambda.

Pour savoir comment définir une fonction lors de la création du groupe d’actions, consultez Ajout d’un groupe d’actions à 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 à manipuler la logique métier au sein de la fonction à l’aide de tout champ d’événement d’entrée afin que l’action soit menée à bien. Pour plus d’informations sur les fonctions Lambda, consultez Invocation basée sur les é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 des détails de fonction :

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 des détails de fonction, 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",
    "function": "string",
    "parameters": [
        {
            "name": "string",
            "type": "string",
            "value": "string"
        },
    ...
    ],
    "sessionAttributes": {
        "string": "string",
    },
    "promptSessionAttributes": {
        "string": "string"
    }
}

La liste suivante décrit les champs d’événement d’entrée :

messageVersion : version du message identifiant le format des données d’événement entrant dans la fonction Lambda et le 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 dans l’opération d’API, tel que défini dans le schéma OpenAPI, 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 : chemin d’accès à l’opération d’API, tel que défini dans le schéma OpenAPI.
- httpMethod : méthode de l’opération d’API, telle que définie dans le schéma OpenAPI.
- requestBody : contient le corps de la demande et ses propriétés, tels que définis dans le schéma OpenAPI pour le groupe d’actions.
Si vous avez défini le groupe d’actions avec des détails de fonction, l’événement d’entrée contient le champ suivant :
- function : 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 cours 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 se compose de 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 de réponse maximale de données utiles correspond à la taille maximale d’une réponse synchrone de la fonction Lambda. Pour plus d’informations, consultez le quota de ressources de données utiles d’invocation 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 des détails de fonction :

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 des détails de 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 le 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 se trouver dans la réponse :
  - apiPath : chemin d’accès à l’opération d’API, tel que défini dans le schéma OpenAPI.
  - httpMethod : méthode de l’opération d’API, telle que définie dans le schéma OpenAPI.
  - httpStatusCode : code de statut HTTP renvoyé par l’opération d’API.
  - responseBody : contient le corps de la réponse, tel que défini dans le schéma OpenAPI.
- Si vous avez défini le groupe d’actions avec des détails de fonction, les champs suivants peuvent se trouver dans la réponse :
  - responseState (Facultatif) : définissez ce champ sur l’un des états suivants pour définir le comportement de l’agent après le traitement de l’action :
    
    FAILURE : l’agent génère une DependencyFailedException pour la session en cours. S’applique lorsque l’exécution de la fonction échoue en raison d’un échec de dépendance.
    
    REPROMPT : l’agent transmet une chaîne de réponse au modèle pour lui envoyer une nouvelle invite. 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 (À l’heure actuelle, seul le type TEXT est pris en charge.) et la valeur est un objet contenant le body de la réponse.
(Facultatif) sessionAttributes : contient les attributs de session et leurs valeurs. Pour plus d’informations, consultez Attributs de session et de session d’invite.
(Facultatif) promptSessionAttributes : contient les attributs d’invite et leurs valeurs. Pour plus d’informations, consultez Attributs de session et de session d’invite.
(Facultatif) knowledgeBasesConfiguration : contient une liste de configurations de requêtes pour les bases de connaissances attachées à l’agent. Pour plus d’informations, consultez Configurations d’extraction de la base de connaissances.

Exemple de fonction Lambda d’un groupe d’actions

Voici un exemple minime de la façon dont la fonction Lambda peut être définie en Python. Cliquez sur l’onglet correspondant à la définition ou non du groupe d’actions avec un schéma OpenAPI ou des détails de 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

Gestion de l’exécution de l’action

Redonner le contrôle au développeur de l’agent