Lambda-Eingabeereignis von Amazon Bedrock Lambda-Antwortereignis auf Amazon Bedrock Beispiel für eine Aktionsgruppe mit Lambda-Funktionen

Konfigurieren von Lambda-Funktionen zum Senden von Informationen, die ein Amazon-Bedrock-Agent beim Benutzer abfragt

Sie können eine Lambda-Funktion definieren, um die Geschäftslogik für die Aktionsgruppe zu programmieren. Nachdem ein Amazon-Bedrock-Agent die API-Operation ermittelt hat, die er in einer Aktionsgruppe aufrufen muss, sendet er Informationen aus dem API-Schema zusammen mit relevanten Metadaten als Eingabeereignis an die Lambda-Funktion. Um Ihre Funktion zu schreiben, müssen Sie die folgenden Komponenten der Lambda-Funktion verstehen:

Eingabeereignis – Enthält relevante Metadaten und ausgefüllte Felder aus dem Anforderungstext der API-Operation oder die Funktionsparameter für die Aktion, die laut Agent aufgerufen werden muss.
Antwort – Enthält relevante Metadaten und ausgefüllte Felder für den Antworttext, der von der API-Operation oder der Funktion zurückgegeben wurde.

Sie schreiben Ihre Lambda-Funktion, um zu definieren, wie eine Aktionsgruppe zu handhaben ist, und um anzupassen, wie die API-Antwort zurückgegeben werden soll. Sie verwenden die Variablen aus dem Eingabeereignis, um Ihre Funktionen zu definieren und eine Antwort an den Agenten zurückzugeben.

Anmerkung

Eine Aktionsgruppe kann bis zu 11 API-Operationen enthalten, Sie können jedoch nur eine Lambda-Funktion schreiben. Da die Lambda-Funktion nur ein Eingabeereignis empfangen und eine Antwort für jeweils eine API-Operation zurückgeben kann, sollten Sie die Funktion unter Berücksichtigung der verschiedenen API-Operationen schreiben, die aufgerufen werden können.

Damit Ihr Agent eine Lambda-Funktion verwenden kann, müssen Sie der Funktion eine ressourcenbasierte Richtlinie hinzufügen, um dem Agenten Berechtigungen zu erteilen. Führen Sie die Schritte unter Ressourcenbasierte Richtlinie, die es Amazon Bedrock erlaubt, die Lambda-Funktion einer Aktionsgruppe aufzurufen aus, um weitere Informationen zu erhalten. Weitere Informationen zu ressourcenbasierte Richtlinien in Lambda finden Sie unter Verwenden von ressourcenbasierten Richtlinien für Lambda im Entwicklerhandbuch zu AWS Lambda.

Informationen zum Definieren einer Funktion bei der Erstellung der Aktionsgruppe finden Sie unter Hinzufügen einer Aktionsgruppe zu Ihrem Agenten in Amazon Bedrock.

Themen

Lambda-Eingabeereignis von Amazon Bedrock
Lambda-Antwortereignis auf Amazon Bedrock
Beispiel für eine Aktionsgruppe mit Lambda-Funktionen

Lambda-Eingabeereignis von Amazon Bedrock

Wenn eine Aktionsgruppe aufgerufen wird, die eine Lambda-Funktion verwendet, sendet Amazon Bedrock ein Lambda-Eingabeereignis im folgenden allgemeinen Format. Sie können Ihre Lambda-Funktion so definieren, dass sie eines der Eingabeereignisfelder verwendet, um die Geschäftslogik innerhalb der Funktion entsprechend anzupassen, damit die Aktion erfolgreich ausgeführt wird. Weitere Informationen zu Lambda-Funktionen finden Sie unter Ereignisgesteuerter Aufruf im Entwicklerhandbuch zu AWS Lambda.

Das Format des Eingabeergebnisses hängt davon ab, ob Sie die Aktionsgruppe mit einem API-Schema oder mit Funktionsdetails definiert haben:

Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, lautet das Eingabeereignisformat wie folgt:


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

Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, lautet das Eingabeereignisformat wie folgt:


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

Die folgende Liste beschreibt die Eingabeereignisfelder:

messageVersion – Die Version der Mitteilung, die das Format der Ereignisdaten, die in die Lambda-Funktion eingehen, und das erwartete Format der Antwort von einer Lambda-Funktion identifiziert. Amazon Bedrock unterstützt nur die Version 1.0.
agent: Enthält Informationen über den Namen, die ID, den Alias und die Version des Agenten, dem die Aktionsgruppe angehört.
inputText: Die Benutzereingabe für den Gesprächsabschnitt.
sessionId: Die eindeutige Kennung für die Sitzung des Agenten.
actionGroup: Der Name der Aktionsgruppe.
parameters – Enthält eine Liste von Objekten. Jedes Objekt enthält den Namen, den Typ und den Wert eines Parameters in der API-Operation, wie im OpenAPI-Schema oder in der Funktion definiert.
Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, enthält das Eingabeereignis die folgenden Felder:
- apiPath – Der Pfad zur API-Operation, wie im OpenAPI-Schema definiert.
- httpMethod – Die Methode der API-Operation, wie im OpenAPI-Schema definiert.
- requestBody – Enthält den Text der Anforderung und ihre Eigenschaften, wie im OpenAPI-Schema für die Aktionsgruppe definiert.
Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, enthält das Eingabeereignis die folgenden Felder:
- function – Der Name der Funktion, wie in den Funktionsdetails für die Aktionsgruppe definiert.
sessionAttributes – Enthält Sitzungsattribute und ihre Werte. Diese Attribute werden während einer Sitzung gespeichert und stellen den Kontext für den Agenten bereit.
promptSessionAttributes – Enthält Prompt-Sitzungsattribute und ihre Werte. Diese Attribute werden nacheinander gespeichert und stellen den Kontext für den Agenten bereit.

Lambda-Antwortereignis auf Amazon Bedrock

Amazon Bedrock erwartet eine Antwort Ihrer Lambda-Funktion im folgenden Format. Die Antwort besteht aus Parametern, die von der API-Operation zurückgegeben wurden. Der Agent kann die Antwort der Lambda-Funktion für die weitere Orchestrierung verwenden oder ihr helfen, eine Antwort an den Kunden zurückzugeben.

Anmerkung

Die maximale Größe der Nutzdatenantwort entspricht der maximalen Größe einer synchronen Antwort von der Lambda-Funktion. Weitere Informationen finden Sie im Ressourcenkontingent für die Nutzdaten des Aufrufs im Entwicklerhandbuch zu AWS Lambda.

Das Format des Eingabeergebnisses hängt davon ab, ob Sie die Aktionsgruppe mit einem API-Schema oder mit Funktionsdetails definiert haben:

Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, lautet das Eingabeereignisformat wie folgt:


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

Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, lautet das Antwortformat wie folgt:


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

In der folgenden Liste werden die Lambda-Antwortfelder beschrieben:

messageVersion – Die Version der Nachricht, die das Format der Ereignisdaten identifiziert, die in die Lambda-Funktion eingegeben werden, sowie das erwartete Format der Antwort von einer Lambda-Funktion. Amazon Bedrock unterstützt nur die Version 1.0.
response: Enthält die folgenden Informationen über die API-Antwort.
- actionGroup: Der Name der Aktionsgruppe.
- Wenn Sie die Aktionsgruppe mit einem API-Schema definiert haben, muss die Antwort das folgende Format haben:
  - apiPath – Der Pfad zur API-Operation, wie im OpenAPI-Schema definiert.
  - httpMethod – Die Methode der API-Operation, wie im OpenAPI-Schema definiert.
  - httpStatusCode – Der von der API-Operation zurückgegebene HTTP-Statuscode.
  - responseBody – Enthält den Antworttext, wie im OpenAPI-Schema definiert.
- Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, können die folgenden Felder in der Antwort enthalten sein:
  - responseState (Optional) – Legen Sie einen der folgenden Status fest, um das Verhalten des Agenten nach der Verarbeitung der Aktion zu definieren:
    
    FAILURE – Der Agent gibt eine DependencyFailedException für die aktuelle Sitzung aus. Gilt, wenn die Funktionsausführung aufgrund eines Abhängigkeitsfehlers fehlschlägt.
    
    REPROMPT – Der Agent übergibt eine Antwortzeichenfolge an das Modell, um es erneut aufzufordern. Gilt, wenn die Funktionsausführung aufgrund einer ungültigen Eingabe fehlschlägt.
  - responseBody – Enthält ein Objekt, das die Antwort von der Ausführung der Funktion definiert. Der Schlüssel ist der Inhaltstyp (derzeit wird nur TEXT unterstützt) und der Wert ist ein Objekt, das den body der Antwort enthält.
(Optional) sessionAttributes: Enthält Sitzungsattribute und ihre Werte. Weitere Informationen finden Sie unter Sitzungs- und Prompt-Sitzungsattribute.
(Optional) promptSessionAttributes: Enthält Prompt-Attribute und ihre Werte. Weitere Informationen finden Sie unter Sitzungs- und Prompt-Sitzungsattribute.
(Optional) knowledgeBasesConfiguration – Enthält eine Liste von Abfragekonfigurationen für Wissensdatenbanken, die an den Agenten angefügt sind. Weitere Informationen finden Sie unter Konfigurationen für den Abruf aus der Wissensdatenbank.

Beispiel für eine Aktionsgruppe mit Lambda-Funktionen

Im Folgenden sehen Sie ein minimal gehaltenes Beispiel dafür, wie die Lambda-Funktion in Python definiert werden kann. Wählen Sie die Registerkarte aus, die der Angabe entspricht, ob Sie die Aktionsgruppe mit einem OpenAPI-Schema oder mit Funktionsdetails definiert haben:

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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verarbeiten der Ausführung der Aktion

Zurückgeben der Steuerung an den Agent-Entwickler