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.

Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen

Sie können die Amazon-Bedrock-API verwenden, um einem Modell Zugriff auf Tools zu gewähren, mit deren Hilfe es Antworten auf Nachrichten generieren kann, die Sie an das Modell senden. Möglicherweise verfügen Sie über eine Chat-Anwendung, mit der Benutzer ermitteln können, welcher Song bei einem Radiosender am beliebtesten ist. Um eine Anfrage nach dem beliebtesten Song zu beantworten, benötigt ein Modell ein Tool, das die Titelinformationen abfragen und zurückgeben kann.

In Amazon Bedrock wird das Tool nicht direkt vom Modell aufgerufen. Vielmehr stellen Sie beim Senden einer Nachricht an ein Modell auch eine Definition für ein oder mehrere Tools bereit, mit denen das Modell möglicherweise eine Antwort generieren kann. In diesem Beispiel würden Sie eine Definition für ein Tool angeben, das den beliebtesten Song für einen bestimmten Radiosender zurückgibt. Wenn das Modell feststellt, dass es das Tool benötigt, um eine Antwort auf die Nachricht zu generieren, kann das Modell, abhängig von der API, die zum Aufrufen des Modells verwendet wurde, entweder clientseitige Aufrufe durchführen oder Bedrock bitten, das Tool mithilfe serverseitiger Tool-Aufrufe aufzurufen. Lassen Sie uns diese beiden Optionen genauer besprechen.

Clientseitiges Aufrufen von Tools

Wenn Sie die Responses API, Chat Completions API, Converse API oder InvokeModel API verwenden, um die Anfrage zu senden, verwendet das Modell clientseitige Tool-Aufrufe. Das bedeutet, dass Sie in Ihrem Code das Tool im Namen des Modells aufrufen. Gehen Sie in diesem Szenario davon aus, dass es sich bei der Tool-Implementierung um eine API handelt. Das Tool könnte genauso gut eine Datenbank, eine Lambda-Funktion oder eine andere Software sein. Sie entscheiden, wie Sie das Tool implementieren möchten. Anschließend setzen Sie die Konversation mit dem Modell fort, indem Sie eine Nachricht mit dem Ergebnis des Tools bereitstellen. Schließlich generiert das Modell eine Antwort auf die ursprüngliche Nachricht, die die Werkzeugergebnisse enthält, die Sie an das Modell gesendet haben.

Lassen Sie uns das Werkzeug definieren, das wir für die Verwendung des Werkzeugs verwenden werden. Die folgenden Python-Beispiele zeigen, wie ein Tool verwendet wird, das den beliebtesten Song eines fiktiven Radiosenders zurückgibt.

def get_most_popular_song(station_name: str) -> str:
    stations = {
        "Radio Free Mars": "Starman – David Bowie",
        "Neo Tokyo FM": "Plastic Love – Mariya Takeuchi",
        "Cloud Nine Radio": "Blinding Lights – The Weeknd",
    }
    return stations.get(station_name, "Unknown Station – No chart data available")

Verwendung der Responses API für clientseitige Tools

Sie können die von OpenAI bereitgestellte Funktion zum Aufrufen von Funktionen verwenden, um dieses Tool aufzurufen. Die Responses API ist die bevorzugte API von OpenAI. Hier ist der Python-Code für die Responses API für clientseitiges Tooling:

from openai import OpenAI
import json

client = OpenAI()

response = client.responses.create(
    model="oss-gpt-120b",
    input="What is the most popular song on Radio Free Mars?",
    tools=[
        {
            "type": "function",
            "name": "get_most_popular_song",
            "description": "Returns the most popular song on a radio station",
            "parameters": {
                "type": "object",
                "properties": {
                    "station_name": {
                        "type": "string",
                        "description": "Name of the radio station"
                    }
                },
                "required": ["station_name"]
            }
        }
    ]
)

if response.output and response.output[0].content:
    tool_call = response.output[0].content[0]
    args = json.loads(tool_call["arguments"])
    result = get_most_popular_song(args["station_name"])
    
    final_response = client.responses.create(
        model="oss-gpt-120b",
        input=[
            {
                "role": "tool",
                "tool_call_id": tool_call["id"],
                "content": result
            }
        ]
    )
    
    print(final_response.output_text)

Verwendung der Chat Completions API für clientseitige Tools

Sie können auch die Chat Completions API verwenden. Hier ist der Python-Code für die Verwendung von Chat Completions:

    from openai import OpenAI
import json

client = OpenAI()

completion = client.chat.completions.create(
    model="oss-gpt-120b",
    messages=[{"role": "user", "content": "What is the most popular song on Neo Tokyo FM?"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_most_popular_song",
            "description": "Returns the most popular song on a radio station",
            "parameters": {
                "type": "object",
                "properties": {
                   "station_name": {"type": "string", "description": "Name of the radio station"}
                },
                "required": ["station_name"]
            }
        }
    }]
)

message = completion.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    result = get_most_popular_song(args["station_name"])

    followup = client.chat.completions.create(
        model="oss-gpt-120b",
        messages=[
            {"role": "user", "content": "What is the most popular song on Neo Tokyo FM?"},
            message,
            {"role": "tool", "tool_call_id": tool_call.id, "content": result}
        ]
    )

    print(followup.choices[0].message.content)
    

Weitere Informationen zur Verwendung von Function Calling on Responses API und Chat Completions API finden Sie unter Function Calling in OpenAI.

Verwendung der Converse-API für clientseitige Tools

Sie können die Converse-API verwenden, damit ein Modell ein Tool in einer Konversation verwenden kann. Die folgenden Python-Beispiele zeigen, wie ein Tool verwendet wird, das den beliebtesten Song eines fiktiven Radiosenders zurückgibt.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""Shows how to use tools with the Converse API and the Cohere Command R model."""

import logging
import json
import boto3
from botocore.exceptions import ClientError


class StationNotFoundError(Exception):
    """Raised when a radio station isn't found."""
    pass


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def get_top_song(call_sign):
    """Returns the most popular song for the requested station.

    Args:
        call_sign (str): The call sign for the station for which you want
            the most popular song.

    Returns:
        response (json): The most popular song and artist.
    """
    song = ""
    artist = ""

    if call_sign == 'WZPZ':
        song = "Elemental Hotel"
        artist = "8 Storey Hike"
    else:
        raise StationNotFoundError(f"Station {call_sign} not found.")

    return song, artist


def generate_text(bedrock_client, model_id, tool_config, input_text):
    """Generates text using the supplied Amazon Bedrock model. If necessary,
    the function handles tool use requests and sends the result to the model.

    Args:
        bedrock_client: The Boto3 Bedrock runtime client.
        model_id (str): The Amazon Bedrock model ID.
        tool_config (dict): The tool configuration.
        input_text (str): The input text.

    Returns:
        Nothing.
    """
    logger.info("Generating text with model %s", model_id)

    # Create the initial message from the user input.
    messages = [{"role": "user",
                 "content": [{"text": input_text}]}]

    response = bedrock_client.converse(modelId=model_id,
                                       messages=messages,
                                       toolConfig=tool_config)

    output_message = response['output']['message']
    messages.append(output_message)

    stop_reason = response['stopReason']

    if stop_reason == 'tool_use':
        # Tool use requested. Call the tool and send the result to the model.
        tool_requests = response['output']['message']['content']

        for tool_request in tool_requests:
            if 'toolUse' in tool_request:
                tool = tool_request['toolUse']
                logger.info("Requesting tool %s. Request: %s",
                            tool['name'], tool['toolUseId'])

                if tool['name'] == 'top_song':
                    tool_result = {}
                    try:
                        song, artist = get_top_song(tool['input']['sign'])
                        tool_result = {"toolUseId": tool['toolUseId'],
                                       "content": [{"json": {"song": song, "artist": artist}}]}
                    except StationNotFoundError as err:
                        tool_result = {"toolUseId": tool['toolUseId'],
                                       "content": [{"text": err.args[0]}],
                                       "status": 'error'}

                    tool_result_message = {"role": "user",
                                           "content": [{"toolResult": tool_result}]}
                    messages.append(tool_result_message)

        # Send the tool result to the model.
        response = bedrock_client.converse(modelId=model_id,
                                           messages=messages,
                                           toolConfig=tool_config)

        output_message = response['output']['message']

    # print the final response from the model.
    for content in output_message['content']:
        print(json.dumps(content, indent=4))


def main():
    """Entrypoint for tool use example."""
    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "cohere.command-r-v1:0"
    input_text = "What is the most popular song on WZPZ?"

    tool_config = {
        "tools": [
            {
                "toolSpec": {
                    "name": "top_song",
                    "description": "Get the most popular song played on a radio station.",
                    "inputSchema": {
                        "json": {
                            "type": "object",
                            "properties": {
                                "sign": {
                                    "type": "string",
                                    "description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ, and WKRP."
                                }
                            },
                            "required": ["sign"]
                        }
                    }
                }
            }
        ]
    }

    bedrock_client = boto3.client(service_name='bedrock-runtime')

    try:
        print(f"Question: {input_text}")
        generate_text(bedrock_client, model_id, tool_config, input_text)
    except ClientError as err:
        message = err.response['Error']['Message']
        logger.error("A client error occurred: %s", message)
        print(f"A client error occured: {message}")
    else:
        print(f"Finished generating text with model {model_id}.")


if __name__ == "__main__":
    main()

Verwenden von Invoke APIs für die Verwendung von clientseitigen Tools

Es ist möglich, Tools mit den grundlegenden Inferenzoperationen (oder) zu verwenden. InvokeModelInvokeModelWithResponseStream Informationen zu den Inferenzparametern, die Sie im Anforderungstext übergeben, finden Sie in den Inferenzparametern für das Modell, das Sie verwenden möchten.

Serverseitiger Werkzeugaufruf

Wenn Sie die Responses API verwenden, um das Modell aufzurufen, kann es zusätzlich zu den zuvor erläuterten clientseitigen Toolaufrufen auch serverseitige Tool-Aufrufe verwenden. Der serverseitige Werkzeugaufruf ist ein Mechanismus, bei dem Tools (APIs, Funktionen, Workflows) in einer vertrauenswürdigen Backend-Umgebung und nicht auf dem Client ausgeführt werden. Dies verbessert die Sicherheit, Zuverlässigkeit und Steuerung der Anwendung. Bevor Amazon Bedrock die Lambda-Funktion ausführt, die die Verwendung des Tools implementiert, wird sichergestellt, dass für die Lambda-Funktion dieselbe IAM-Richtlinie gilt wie für die Anwendung, die sie aufruft. Da Amazon Bedrock die Ausführung der Tools vorantreibt, können sich Kunden auf die Implementierung ihrer Geschäftslogik konzentrieren, anstatt Toolfunktionen hinzuzufügen. Amazon Bedrock unterstützt auch die höchsten Governance-Standards wie ISO, SOC und HIPAA-tauglich. Kunden können entweder ihre eigene benutzerdefinierte Lambda-Funktion einreichen, um das Tool auszuführen, oder vorhandene vordefinierte Tools wie Notizen und Aufgaben verwenden. Serverseitige Tools, die die Responses API verwenden, sind ab den GPT OSS 20B/120B-Modellen von OpenAI verfügbar. Weitere Modelle werden in Kürze unterstützt. Sie können die Models-API verwenden, um verfügbare Modelle zu finden, die Sie mit der Responses API verwenden können. Weitere Informationen zur Responses API finden Sie unter Generieren von Antworten mit OpenAI APIs.

Es gibt zwei Arten von Tools, die Sie mit Amazon Bedrock verwenden können: Benutzerdefinierte Tools, die Lambda verwenden, oder vordefinierte Tools, die von Bedrock unterstützt werden. In diesem Abschnitt erfahren Sie, wie Sie mit der Responses API ein benutzerdefiniertes Lambda-Tool erstellen. Lassen Sie uns beide im Detail besprechen.

Benutzerdefinierte Tools, die Lambda in Responses API verwenden

Durch die Verwendung einer Lambda-Funktion als benutzerdefiniertes Tool in Bedrock können Sie die Funktionen des Agenten erweitern, indem Sie benutzerdefinierte AWS Lambda Lambda-Funktionen als Tools integrieren. Auf diese Weise können Sie serverlose, skalierbare Tools erstellen, die von KI-Assistenten und anderen Anwendungen über das Model Context Protocol (MCP) aufgerufen werden können. Hier sind die Vorteile dieser Funktion:

Damit ein Modell in Amazon Bedrock ein Tool verwenden kann, um eine Antwort auf eine Nachricht abzuschließen, senden Sie die Nachricht und die Definitionen für ein oder mehrere Tools an das Modell. Wenn das Modell auf der Grundlage der Aufforderung Ihrer Anwendung feststellt, dass eines der Tools bei der Generierung einer Antwort helfen kann, sendet es eine Anfrage an Bedrock zurück, das Tool zu verwenden und die Werkzeugergebnisse an das Modell zurückzusenden. Das Modell verwendet dann die Ergebnisse, um eine Antwort auf die ursprüngliche Nachricht zu generieren.

Die folgenden Schritte zeigen, wie Sie ein Tool mit der Responses API verwenden.

Funktionsweise

Schritt 1: Definieren Sie die Lambda-Funktion, um den beliebtesten Song zu erhalten

Erstellen Sie eine Lambda-Funktion, die das MCP-Protokoll implementiert. Hier ist ein einfaches Python-Beispiel:

import json

def lambda_handler(event, context):
    # Parse JSON-RPC request
    method = event.get('method')
    params = event.get('params', {})
    request_id = event.get('id')
    
    if method == 'tools/list':
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "tools": [
                    {
                        "name": "my_custom_tool",
                        "description": "My custom business logic tool",
                        "inputSchema": {
                            "type": "object",
                            "properties": {
                                "input": {
                                    "type": "string",
                                    "description": "Input text to process"
                                }
                            },
                            "required": ["input"]
                        }
                    }
                ]
            }
        }
    elif method == 'tools/call':
        tool_name = params.get('name')
        arguments = params.get('arguments', {})
        
        if tool_name == 'my_custom_tool':
            # Your custom logic here
            result = f"Processed: {arguments.get('input', '')}"
            return {
                "jsonrpc": "2.0",
                "id": request_id,
                "result": {
                    "content": [
                        {
                            "type": "text",
                            "text": result
                        }
                    ]
                }
            }
    
    # Error response for unsupported methods
    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "error": {
            "code": -32601,
            "message": "Method not found"
        }
    }

Schritt 2: Stellen Sie die Lambda-Funktion bereit

Verwenden Sie als Nächstes Ihre IAM-Rolle, um diese Lambda-Funktion bereitzustellen, um einen ARN zu erhalten. Weitere Informationen zur Bereitstellung einer Lambda-Funktion finden Sie hier.

# Example using AWS CLI
aws lambda create-function \
  --function-name my-custom-tool \
  --runtime python3.14 \
  --role arn:aws:iam::YOUR-ACCOUNT:role/lambda-execution-role \
  --handler lambda_function.lambda_handler \
  --zip-file fileb://function.zip

Nehmen wir an, Ihr ARN lautet: arn:aws:lambda:us-west-2:123456789012:function:my-custom-tool

Schritt 3: Definieren Sie die Nachricht und die Tooldefinition in Ihrer Inferenzanfrage

Um die Nachricht und die Tooldefinition zu senden, verwenden Sie die Response-API-Operationen. Amazon Bedrock verwendet die Konnektoren und Remote-MCP-Serverfunktionen der Responses API, um Funktionen zur Verwendung von Tools bereitzustellen. Die Definition des Tools ist ein JSON-Schema, das Sie im mcp-Anforderungsparameter an den Create-Vorgang übergeben. In dem connector_id Feld in der Responses Connectors API können Sie den Lambda-ARN übergeben, den Sie im vorherigen Schritt erstellt haben. Sie müssen keine Autorisierungsdaten angeben, da Bedrock dieselben IAM-Rollen und Richtlinien verwendet wie Ihre Anwendung, die das Modell aufruft. Nachfolgend finden Sie ein Beispielschema für ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="oss-gpt-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "xamzn_arn",
            "connector_id": "arn:aws:lambda:us-west-2:123456789012:function:my-custom-tool",
            "require_approval": "never",
        },
    ],
    input="My custom prompt.",
)

print(resp.output_text)

Schritt 4: Bedrock ruft das Tool auf und gibt die Antwort zurück an das Modell

Die Möglichkeit, das Connector-Tool zu verwenden, ist in den Modellen verfügbar, die die Responses API unterstützen. Prüfen Sie hier, welche Tools Ihr Modell unterstützen. Wenn Sie Tools verwenden, die die Responses API verwenden, zahlen Sie nur für Token, die beim Import von Tooldefinitionen oder bei Toolaufrufen verwendet werden. Pro Tool-Aufruf fallen keine zusätzlichen Gebühren an.

Wenn Sie im tools Parameter eine Lambda-Funktion angeben, versucht die API, eine Liste von Tools vom Server abzurufen. Wenn die Liste der Tools erfolgreich abgerufen werden kann, erscheint ein neues mcp_list_tools Ausgabeelement in der Ausgabe der Modellantwort. In der tools Eigenschaft dieses Objekts werden die Werkzeuge angezeigt, die erfolgreich importiert wurden. Sobald das Modell Zugriff auf diese Werkzeugdefinitionen hat, kann es sie je nach Kontext des Modells aufrufen. Wenn das Modell beschließt, ein Lambda-Tool aufzurufen, sendet die API eine Anfrage an die Lambda-Funktion, das Tool aufzurufen und seine Ausgabe in den Kontext des Modells zu stellen. Weitere Informationen zu den Listentools und Aufruf-Tools finden Sie in der OpenAI-Dokumentation. Beachten Sie, dass Ihrer Lambda-Funktion dieselben IAM-Rollen und Richtlinien zugewiesen sein müssen wie der Anwendung, die das Modell in Bedrock aufruft. Andernfalls schlägt die Lambda-Funktion fehl. Im Folgenden finden Sie die Fehlerdefinition.

{
    "jsonrpc": "2.0",
    "id": 1,
    "error": {
        "code": -32000,
        "message": "Tool execution failed",
        "data": "Additional error details"
    }
}

Verwendung der von AWS bereitgestellten Tools in der Responses API

Es gibt zwei von AWS bereitgestellte Tools, die in Bedrock verfügbar sind: Notizfunktion (Notizen-Tool) und Aufgabenverwaltung (Aufgabentool). Lassen Sie uns beide im Detail durchgehen.

Überblick über das Notizen-Tool

Mit dem notes Tool können Sie Schlüssel-Wert-Paare innerhalb derselben Konversationssitzung speichern und abrufen. Dies bietet einen einfachen Speichermechanismus, um den Kontext über mehrere Interaktionen hinweg aufrechtzuerhalten. Bei Schlüsseln wird zwischen Groß- und Kleinschreibung unterschieden, und es gibt keine Begrenzung der Schlüssellänge oder der Namenskonventionen. Das System überschreibt vorherige Werte für denselben Schlüssel. Werte werden als Zeichenketten (JSON URLs usw.) gespeichert, und es gibt keine Größenbeschränkungen auf Toolebene. Werte werden während der gesamten Konversationssitzung beibehalten. Der Speicher ist nur auf die aktuelle Konversation beschränkt.

Parameter

Gültige Operationen

Sie können jede natürliche Sprache verwenden (z. B. „Denken Sie daran, dass meine Lieblingsfarbe Blau ist“, „Was habe ich Ihnen über meine Lieblingsfarbe erzählt?“ , „Speichern Sie die Tatsache, dass ich Besprechungen am Vormittag bevorzuge“, „Erinnern Sie sich daran, was ich zu den Besprechungspräferenzen gesagt habe“), oder Sie können in Ihrer Aufforderung direkte Tools-Aufrufe verwenden („Verwenden Sie das Notizen-Tool, um meine E-Mail als john@example.com zu speichern“, „Überprüfen Sie die Notizen auf meine E-Mail-Adresse“).

Überblick über das Aufgabentool

Das tasks Tool bietet einen Last-In-First-Out (LIFO-) Stack für die Verwaltung von Aufgaben innerhalb einer Konversationssitzung. Auf diese Weise können Sie Aufgaben auf einen Stapel verschieben und sie in umgekehrter Reihenfolge wieder herausnehmen. Dies macht es perfekt für die Verwaltung verschachtelter Workflows, temporärer Erinnerungen oder die hierarchische Aufgabenverwaltung. Aufgaben bleiben während der gesamten Konversationssitzung bestehen. Der Stack-Status wird über mehrere Interaktionen hinweg beibehalten. Der Speicher ist nur auf die aktuelle Konversation beschränkt.

Sie können das Aufgaben-Tool aufrufen, indem Sie entweder natürliche Sprachen verwenden (z. B. „Fügen Sie eine Aufgabe hinzu, um das Budget zu überprüfen“, „Senden Sie eine Erinnerung, um den Kunden anzurufen“, „Was ist die nächste Aufgabe, die ich erledigen muss?“ , „Aktuellste Aufgabe anzeigen“, „Aktuelle Aufgabe aus meinem Stapel abrufen“) oder Sie können das Tool direkt in Ihrer Aufforderung aufrufen („Verwenden Sie das Aufgabentool, um auf „Präsentation beenden“ zu klicken, „Eine Aufgabe aus dem Stapel herausnehmen“, „Meiner Aufgabenliste ‚Besprechung' hinzufügen“).

Serverseitige Integration zur Verwendung von Tools mit Gateway AgentCore

Amazon Bedrock unterstützt jetzt AgentCore Gateway als Integrationstyp für serverseitige Tools, die Tools aufrufen. Mit dieser Funktion können Sie Ihre Modelle direkt mit AgentCore Gateway-Endpunkten verbinden und so einen nahtlosen Zugriff auf Tools ermöglichen, die über die Gateway-Infrastruktur verwaltet werden.

Die AgentCore Gateway-Integration folgt demselben Muster wie die Lambda-Funktionsintegration, mit einem wesentlichen Unterschied.

Lambda-Integration:

AgentCore Gateway-Integration:

Konfiguration

Struktur der Anfrage

Verwenden Sie bei der Konfiguration von AgentCore Gateway als Toolquelle die folgende Struktur in Ihrem tools Array in Ihrer Responses API-Anfrage.

{
  "type":"mcp",
  "server_label":"agentcore_tools",
  "connector_id":"arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp",
  "server_description":"AgentCore Gateway providing custom tools",
  "require_approval":"never"
}

Parameter

Vollständiges Beispiel für eine Anfrage

{
  "model":"openai.gpt-oss-120b",
  "stream":true,
  "background":false,
  "store":false,
  "tools": [
    {
      "type":"mcp",
      "server_label":"agentcore_tools",
      "connector_id":"arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp",
      "server_description":"AgentCore Gateway providing custom tools",
      "require_approval":"never"
    }
  ],
  "input": [
    {
      "type":"message",
      "role":"user",
      "content": [
        {
          "type":"input_text",
          "text":"What is the weather in Seattle?"
        }
      ]
    }
  ]
}

Voraussetzungen

Bevor Sie die AgentCore Gateway-Integration verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:

Vorteile der AgentCore Gateway-Integration

IAM-Berechtigungen

Ihre Bedrock-Ausführungsrolle benötigt die Erlaubnis, das Gateway aufzurufen: AgentCore

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock-agentcore:InvokeGateway"
      ],
      "Resource": "arn:aws:bedrock-agentcore:us-west-2:342789630635:gateway/agentcore-intro-gateway-v2-swvq44sovp"
    }
  ]
}

Nächste Schritte