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

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Configura le funzioni Lambda per inviare informazioni che un agente Amazon Bedrock riceve dall'utente

È possibile definire una funzione Lambda per programmare la logica di business per un gruppo di azioni. Dopo che un agente Amazon Bedrock ha determinato l'operazione API da richiamare in un gruppo di azioni, invia informazioni dallo schema API insieme ai metadati pertinenti come evento di input alla funzione Lambda. 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'azione 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 azioni e 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 azioni 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 richiamate.

Affinché l'agente utilizzi una funzione Lambda, è necessario allegare alla funzione una policy basata sulle risorse per fornire le autorizzazioni all'agente. Per ulteriori informazioni, segui i passaggi riportati in. Policy basata sulle risorse per consentire ad Amazon Bedrock di richiamare una funzione Lambda del gruppo di azioni Per ulteriori informazioni sulle politiche basate sulle risorse in Lambda, consulta Using resource-based policies for Lambda nella Developer Guide. AWS Lambda

Per informazioni su come definire una funzione durante la creazione del gruppo di azioni, vedi. Aggiungi un gruppo d'azione al tuo 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. È possibile 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 Event-driven invocation nella Developer Guide. AWS Lambda

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

  • Se hai definito il gruppo di azioni con uno schema 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 avete definito il gruppo di azioni 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"
    }
}

L'elenco seguente descrive i campi degli eventi 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 nel OpenAPI schema o nella funzione.

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

    • apiPath— Il percorso dell'operazione API, come definito nel OpenAPI schema.

    • httpMethod— Il metodo di funzionamento dell'API, come definito nel OpenAPI schema.

    • requestBody— Contiene il corpo della richiesta e le relative proprietà, come definito nel OpenAPI schema per il gruppo di azioni.

  • Se avete definito il gruppo di azioni con i dettagli della funzione, l'evento di input contiene il seguente campo:

    • function— Il nome della funzione come definito nei dettagli della funzione per il gruppo di azioni.

  • 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 della sessione di richiesta e i relativi valori. Questi attributi vengono archiviati nel corso di un turno e forniscono un contesto all'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 di risposta del payload Lambda è di 25 KB.

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

  • Se hai definito il gruppo di azioni con uno schema API, il formato di 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 azioni con i dettagli della funzione, il formato di 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 seguente 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 azioni con uno schema API, nella risposta possono essere presenti i seguenti campi:

      • apiPath— Il percorso dell'operazione API, come definito nel OpenAPI schema.

      • httpMethod— Il metodo di funzionamento dell'API, come definito nel OpenAPI schema.

      • httpStatusCode— Il codice di stato HTTP restituito dall'operazione API.

      • responseBody— Contiene il corpo della risposta, come definito nel OpenAPI schema.

    • Se hai definito il gruppo di azioni con i dettagli della funzione, nella risposta possono essere presenti i seguenti campi:

      • responseState(Facoltativo) — Impostate uno dei seguenti stati per definire il comportamento dell'agente dopo l'elaborazione dell'azione:

        • ERRORE — L'agente genera un messaggio DependencyFailedException per la sessione corrente. Si applica quando l'esecuzione della funzione fallisce a causa di un errore di dipendenza.

        • REPROMPT — L'agente passa una stringa di risposta al modello per richiederla nuovamente. Si applica quando l'esecuzione della funzione fallisce 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 TEXT è supportato solo) e il valore è un oggetto contenente body la 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 la funzione Lambda può essere definita in Python. Seleziona la scheda corrispondente a se hai definito il gruppo di azioni con un OpenAPI schema o con 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