Configura le funzioni Lambda per inviare informazioni che un agente di Amazon Bedrock ricava dall’utente - Amazon Bedrock
Evento di input Lambda da Amazon BedrockEvento di risposta Lambda ad Amazon BedrockEsempio di funzioni Lambda del gruppo di operazioni

Configura le funzioni Lambda per inviare informazioni che un agente di Amazon Bedrock ricava dall’utente

Puoi definire una funzione Lambda per programmare la logica aziendale per un gruppo di operazioni. Dopo che un agente di Amazon Bedrock ha determinato quale operazione API invocare in un gruppo di operazioni, invia alla funzione Lambda informazioni dallo schema dell’API insieme ai metadati pertinenti come evento di input. Per scrivere una funzione, è necessario conoscere i seguenti componenti della funzione Lambda:

  • Evento di input: contiene i metadati pertinenti e i campi compilati del corpo della richiesta dell’operazione API o dei parametri della funzione per l’operazione che l’agente stabilisce debba essere chiamata.

  • Risposta: contiene i metadati pertinenti e i campi compilati per il corpo della risposta restituito dall’operazione o dalla funzione dell’API.

Scrivi la tua funzione Lambda per definire come gestire un gruppo di operazioni e per personalizzare il modo in cui desideri che venga restituita la risposta dell’API. Le variabili dell’evento di input vengono utilizzate per definire le funzioni e restituire una risposta all’agente.

Nota

Un gruppo di operazioni può contenere fino a 11 operazioni API, ma è possibile scrivere una sola funzione Lambda. Poiché la funzione Lambda può ricevere solo un evento di input e restituire una risposta per un’operazione API alla volta, è necessario scrivere la funzione considerando le diverse operazioni API che possono essere invocate.

Per consentire all’agente di utilizzare una funzione Lambda e fornirgli le autorizzazioni, è necessario allegare alla funzione una policy basata sulle risorse. Per ulteriori informazioni, segui la procedura indicata in Policy basata sulle risorse per consentire ad Amazon Bedrock di invocare una funzione Lambda del gruppo di operazioni. Per ulteriori informazioni sulle policy basate sulle risorse, consulta Uso delle policy basate sulle risorse per Lambda nella Guida per sviluppatori di AWS Lambda.

Per informazioni su come definire una funzione durante la creazione del gruppo di operazioni, consulta Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock.

Evento di input Lambda da Amazon Bedrock

Quando viene richiamato un gruppo di operazioni che utilizza una funzione Lambda, Amazon Bedrock invia un evento di input Lambda nel seguente formato generale. Puoi definire la funzione Lambda in modo che utilizzi uno qualsiasi dei campi degli eventi di input per manipolare la logica aziendale all’interno della funzione per eseguire correttamente l’azione. Per ulteriori informazioni sulle funzioni Lambda, consulta Invocazione basata su eventi nella Guida per sviluppatori di AWS Lambda.

Il formato dell’evento di input dipende dal fatto che il gruppo di operazioni sia stato definito con uno schema dell’API o con i dettagli della funzione:

  • Se hai definito il gruppo di operazioni con uno schema dell’API, il formato dell’evento di input è il seguente:

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

  • Se hai definito il gruppo di operazioni con i dettagli della funzione, il formato dell’evento di input è il seguente:

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

Nella lista riportata di seguito sono descritti i campi dell’evento di input.

  • messageVersion: la versione del messaggio che identifica il formato dei dati dell'evento che giungono alla funzione Lambda e il formato previsto della risposta da parte di una funzione Lambda. Amazon Bedrock supporta solo la versione 1.0.

  • agent: contiene informazioni su nome, ID, alias e versione dell'agente a cui appartiene il gruppo di operazioni.

  • inputText: l'input dell'utente per il turno di conversazione.

  • sessionId: l'identificatore univoco della sessione dell'agente.

  • actionGroup: il nome del gruppo di azione.

  • parameters: contiene un elenco di oggetti. Ogni oggetto contiene il nome, il tipo e il valore di un parametro nell’operazione API, come definito nello schema di OpenAPI o nella funzione.

  • Se hai definito il gruppo di operazioni con uno schema dell’API, l’evento di input contiene i seguenti campi:

    • apiPath: il percorso dell’operazione API, come definito nello schema di OpenAPI.

    • httpMethod: il metodo dell’operazione API, come definito nello schema di OpenAPI.

    • requestBody: contiene il corpo della richiesta e le relative proprietà, come definito nello schema di OpenAPI per il gruppo di operazioni.

  • Se hai definito il gruppo di operazioni con i dettagli della funzione, l’evento di input contiene i seguenti campi:

    • function: il nome della funzione come definito nei dettagli della funzione per il gruppo di operazioni.

  • sessionAttributes: contiene gli attributi della sessione e i relativi valori. Questi attributi vengono archiviati durante una sessione e forniscono un contesto per l’agente.

  • promptSessionAttributes: contiene gli attributi di sessione del prompt e i relativi valori. Questi attributi vengono archiviati durante un turno e forniscono un contesto per l’agente.

Evento di risposta Lambda ad Amazon Bedrock

Amazon Bedrock si aspetta una risposta dalla funzione Lambda nel formato seguente. La risposta è costituita da parametri restituiti dall’operazione API. L'agente può utilizzare la risposta della funzione Lambda per un'ulteriore orchestrazione o come aiuto per restituire una risposta al cliente.

Nota

La dimensione massima della risposta del payload corrisponde alla dimensione massima di una risposta sincrona della funzione Lambda. Per ulteriori informazioni, consulta la quota di risorse del payload di invocazione nella Guida per sviluppatori di AWS Lambda.

Il formato dell’evento di input dipende dal fatto che il gruppo di operazioni sia stato definito con uno schema dell’API o con i dettagli della funzione:

  • Se hai definito il gruppo di operazioni con uno schema dell’API, il formato della risposta è il seguente:

    {
    "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
                }
            }
        },
        ...
    ]
}

  • Se hai definito il gruppo di operazioni con i dettagli della funzione, il formato della risposta è il seguente:

    {
    "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
                    }
                }
            }
        },
        ...
    ]
}

L’elenco fornito di seguito descrive i campi di risposta.

  • messageVersion: la versione del messaggio che identifica il formato dei dati dell'evento che giungono alla funzione Lambda e il formato previsto della risposta da parte di una funzione Lambda. Amazon Bedrock supporta solo la versione 1.0.

  • response: contiene le seguenti informazioni sulla risposta API.

    • actionGroup: il nome del gruppo di azione.

    • Se hai definito il gruppo di operazioni con uno schema dell’API, la risposta può contenere i seguenti campi:

      • apiPath: il percorso dell’operazione API, come definito nello schema di OpenAPI.

      • httpMethod: il metodo dell’operazione API, come definito nello schema di OpenAPI.

      • httpStatusCode: il codice di stato HTTP restituito dall’operazione API.

      • responseBody: contiene il corpo della risposta, come definito nello schema di OpenAPI.

    • Se hai definito il gruppo di operazioni con i dettagli della funzione, la risposta può contenere i seguenti campi:

      • responseState (facoltativo): imposta uno degli stati indicati di seguito per definire il comportamento dell’agente dopo l’elaborazione dell’operazione.

        • ERRORE: l’agente genera una DependencyFailedException per la sessione corrente. Si applica quando l’esecuzione della funzione non riesce a causa di un errore di dipendenza.

        • NUOVO PROMPT: l’agente passa una stringa di risposta al modello per un nuovo prompt. Si applica quando l’esecuzione della funzione non riesce a causa di un input non valido.

      • responseBody: contiene un oggetto che definisce la risposta derivante dall’esecuzione della funzione. La chiave è il tipo di contenuto (attualmente è supportato solo TEXT) e il valore è un oggetto contenente il body della risposta.

  • (Facoltativo) sessionAttributes: contiene gli attributi della sessione e i relativi valori. Per ulteriori informazioni, consulta Attributi della sessione e della sessione di prompt.

  • (Facoltativo) promptSessionAttributes: contiene gli attributi del prompt e i relativi valori. Per ulteriori informazioni, consulta Attributi della sessione e della sessione di prompt.

  • (Facoltativo) knowledgeBasesConfiguration: contiene un elenco di configurazioni di query per le knowledge base collegate all’agente. Per ulteriori informazioni, consulta Configurazioni di recupero della knowledge base.

Esempio di funzioni Lambda del gruppo di operazioni

Di seguito è riportato un esempio minimo di come sia possibile definire una funzione Lambda in Python. Seleziona la scheda corrispondente a seconda se hai definito il gruppo di operazioni con uno schema di OpenAPI o con i dettagli della funzione:

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