Lambda-Funktionen so konfigurieren, dass sie Informationen senden, die ein Amazon Bedrock-Agent dem Benutzer entlockt - Amazon Bedrock
Lambda-Eingabeereignis von Amazon BedrockLambda-Antwortereignis auf Amazon BedrockBeispiel für eine Aktionsgruppe mit Lambda-Funktionen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Lambda-Funktionen so konfigurieren, dass sie Informationen senden, die ein Amazon Bedrock-Agent dem Benutzer entlockt

Sie können eine Lambda-Funktion definieren, um die Geschäftslogik für eine Aktionsgruppe zu programmieren. Nachdem ein Amazon Bedrock-Agent den API Vorgang ermittelt hat, den 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 den Funktionsparametern für die Aktion, von der der Agent feststellt, dass sie aufgerufen werden muss.

  • Antwort — Enthält relevante Metadaten und aufgefü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 mit einer Aktionsgruppe umgegangen werden soll, 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, aber Sie können 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 Berechtigungen für den Agenten bereitzustellen. Folgen Sie den Schritten unter, um weitere Informationen zu erhalten. Ressourcenbasierte Richtlinie, die es Amazon Bedrock ermöglicht, eine Lambda-Funktion für Aktionsgruppen aufzurufen Weitere Informationen zu ressourcenbasierten Richtlinien in Lambda finden Sie unter Using Resource Based Policies for Lambda in der AWS Lambda Entwicklerhandbuch.

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

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 jedes der Eingabeereignisfelder verwendet, um die Geschäftslogik innerhalb der Funktion so zu manipulieren, dass die Aktion erfolgreich ausgeführt wird. Weitere Informationen zu Lambda-Funktionen finden Sie unter Event-driven invocation im AWS Lambda Entwicklerhandbuch.

Das Eingabeereignisformat 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"
    }
}

In der folgenden Liste werden die Eingabeereignisfelder beschrieben;

  • 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 in der OpenAPI Schema oder in der Funktion.

  • Wenn Sie die Aktionsgruppe mit einem API Schema definiert haben, enthält das Eingabeereignis die folgenden Felder:

    • apiPath— Der Pfad zur API Operation, wie definiert in OpenAPI Schema.

    • httpMethod— Die Methode der API Operation, wie sie in der definiert ist OpenAPI Schema.

    • requestBody— Enthält den Hauptteil der Anfrage und seine Eigenschaften, wie in der OpenAPI Schema für die Aktionsgruppe.

  • Wenn Sie die Aktionsgruppe mit Funktionsdetails definiert haben, enthält das Eingabeereignis das folgende Feld:

    • function— Der Name der Funktion, wie er in den Funktionsdetails für die Aktionsgruppe definiert ist.

  • 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 Sitzungsattribute für Eingabeaufforderungen und deren 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 Antwortgröße für Lambda-Payloads beträgt 25 KB.

Das Eingabeereignisformat 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 Antwortformat 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 Antwortfelder beschrieben:

  • 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.

  • 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, können die folgenden Felder in der Antwort enthalten sein:

      • apiPath— Der Pfad zur API Operation, wie definiert in OpenAPI Schema.

      • httpMethod— Die Methode der API Operation, wie sie in der definiert ist OpenAPI Schema.

      • httpStatusCode— Der von der API Operation zurückgegebene HTTP Statuscode.

      • responseBody— Enthält den Antworttext, wie er in der definiert ist OpenAPI Schema.

    • 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 DependencyFailedException für die aktuelle Sitzung einen 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 auf die Ausführung der Funktion definiert. Der Schlüssel ist der Inhaltstyp (TEXTwird derzeit nur unterstützt) und der Wert ist ein Objekt, das body die Antwort enthält.

  • (Optional) sessionAttributes: Enthält Sitzungsattribute und ihre Werte. Weitere Informationen finden Sie unter Sitzungsattribute für Sitzung und Eingabeaufforderung.

  • (Optional) promptSessionAttributes: Enthält Prompt-Attribute und ihre Werte. Weitere Informationen finden Sie unter Sitzungsattribute für Sitzung und Eingabeaufforderung.

  • (Optional) knowledgeBasesConfiguration — Enthält eine Liste von Abfragekonfigurationen für Wissensdatenbanken, die an den Agenten angehängt sind. Weitere Informationen finden Sie unter Konfigurationen für den Abruf der Wissensdatenbank.

Beispiel für eine Aktionsgruppe mit Lambda-Funktionen

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

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