Ein Lambda-Ziel hinzufügen Ein API-Gateway-Phasenziel hinzufügen Ein OpenAPI-Ziel hinzufügen Fügen Sie ein Smithy-Ziel hinzu Fügen Sie ein HTTP-Laufzeitziel hinzu Fügen Sie ein MCP-Serverziel hinzu Fügen Sie ein Connector-Ziel mit Amazon Bedrock Managed Knowledge Bases hinzu Fügen Sie mit dem Web Search Tool ein Connector-Ziel hinzu

Definieren Sie die Gateway-Zielkonfiguration

Die Zielkonfiguration hängt vom Zieltyp ab, den Sie dem Gateway hinzufügen. Weitere Informationen zu unterstützten Gateway-Zieltypen finden Sie unter Unterstützte Ziele für Amazon Bedrock AgentCore Gateways.

Wählen Sie ein Thema aus, um Beispiele für das Hinzufügen eines Zieltyps zu sehen:

Themen

Ein Lambda-Ziel hinzufügen
Ein API-Gateway-Phasenziel hinzufügen
Ein OpenAPI-Ziel hinzufügen
Fügen Sie ein Smithy-Ziel hinzu
Fügen Sie ein HTTP-Laufzeitziel hinzu
Fügen Sie ein MCP-Serverziel hinzu
Fügen Sie ein Connector-Ziel mit Amazon Bedrock Managed Knowledge Bases hinzu
Fügen Sie mit dem Web Search Tool ein Connector-Ziel hinzu

Ein Lambda-Ziel hinzufügen

Sie können Ihrem Gateway mithilfe der AgentCore CLI ein Lambda-Ziel hinzufügen, indem Sie das --type as angeben lambda-function-arn und den Lambda-ARN und eine Tool-Schemadatei bereitstellen.

Zielkonfiguration

Die Zielkonfiguration (oder Nutzlast) für eine Lambda-Funktion enthält die folgenden Felder:

LambdaArn — Der ARN der Lambda-Funktion, die als Ziel verwendet werden soll.
toolSchema — Das Toolschema für das Gateway-Ziel.

Weitere Informationen zu Lambda-Zielen finden Sie unter AWS Lambda-Funktionsziele.

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AgentCore CLI

Um eine Lambda-Funktion als Ziel hinzuzufügen, führen Sie es agentcore add gateway-target mit der --type lambda-function-arn Option aus. Stellen Sie den Lambda-ARN und eine JSON-Datei bereit, die das Toolschema enthält:


agentcore add gateway-target \
  --name MyLambdaTarget \
  --type lambda-function-arn \
  --lambda-arn arn:aws:lambda:us-east-1:123456789012:function:MyFunction \
  --tool-schema-file tools.json \
  --gateway MyGateway
agentcore deploy

AgentCore Python SDK

Mit der AgentCore CLI können Sie ganz einfach ein Lambda-Ziel mit Standardkonfigurationen erstellen.


# Import dependencies
from bedrock_agentcore_starter_toolkit.operations.gateway.client import GatewayClient

# Initialize the client
client = GatewayClient(region_name="us-east-1")

# Create a lambda target.
lambda_target = client.create_mcp_gateway_target(
    gateway=gateway,
    name=None, # If you don't set one, one will be generated.
    target_type="lambda",
    target_payload=None, # Define your own lambda if you pre-created one. Otherwise leave this as None and one will be created for you.
    credentials=None, # If you leave this as None, one will be created for you
)

Das Folgende ist ein Beispielargument, das Sie für das target_payload angeben können. Wenn Sie das target_payload Argument weglassen, wird diese Nutzlast verwendet:


{
    "lambdaArn": "<insert your lambda arn>",
    "toolSchema": {
        "inlinePayload": [
            {
                "name": "get_weather",
                "description": "Get weather for a location",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "the location e.g. seattle, wa"
                        }
                    },
                    "required": [
                        "location"
                    ]
                }
            },
            {
                "name": "get_time",
                "description": "Get time for a timezone",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "timezone": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "timezone"
                    ]
                }
            }
        ]
    }
}

Boto3

Der folgende Python-Code zeigt, wie ein Lambda-Ziel mithilfe des AWS Python-SDK (Boto3) hinzugefügt wird:


import boto3

# Create the agentcore client
agentcore_client = boto3.client('bedrock-agentcore-control')

# Create a Lambda target
target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="LambdaTarget",
    targetConfiguration={
        "mcp": {
            "lambda": {
                "lambdaArn": "arn:aws:lambda:us-west-2:123456789012:function:YourLambdaFunction",
                "toolSchema": {
                    "inlinePayload": [
                        {
                            "name": "get_weather",
                            "description": "Get weather for a location",
                            "inputSchema": {
                                "type": "object",
                                "properties": {"location": {"type": "string"}},
                                "required": ["location"],
                            },
                        },
                        {
                            "name": "get_time",
                            "description": "Get time for a timezone",
                            "inputSchema": {
                                "type": "object",
                                "properties": {"timezone": {"type": "string"}},
                                "required": ["timezone"],
                            },
                        },
                    ]
                }
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "GATEWAY_IAM_ROLE"
        }
    ]
)

Interactive

Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Folgendes ausagentcore, wählen Sie Hinzufügen aus, wählen Sie Gateway Target und dann Lambda-Funktion aus:

Der Assistent fordert Sie dann auf, den Zielnamen, den ARN der Lambda-Funktion, die Tool-Schemadatei und die Konfiguration für die ausgehende Autorisierung einzugeben.

Ein API-Gateway-Phasenziel hinzufügen

Um eine Phase einer API-Gateway-REST-API als Ziel hinzuzufügen, geben Sie den ARN der API und der Phase an und definieren Sie Einstellungen, um Tools im API Gateway zu filtern oder Namen und Beschreibungen von Tools im Gateway zu überschreiben:

Die folgenden Beispiele zeigen, wie ein API-Gateway-Ziel hinzugefügt wird. Die folgenden Konfigurationen werden ebenfalls angewendet:

Bei den Tools, nach denen gefiltert wurde, handelt es sich um die Methoden GET und POST für den /products Pfad.
GET /products wurde umbenannt in. get_items

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AgentCore CLI

Um einen API-Gateway-REST-API-Schritt als Ziel hinzuzufügen, führen Sie ihn agentcore add gateway-target mit der folgenden --type api-gateway Option aus:


agentcore add gateway-target \
  --name MyAPIGatewayTarget \
  --type api-gateway \
  --rest-api-id your-rest-api-id \
  --stage your-stage \
  --gateway MyGateway
agentcore deploy

AWS CLI

Der folgende Befehl verwendet die AWS CLI:


aws bedrock-agentcore-control create-gateway-target \
    --gateway-identifier "your-gateway-id" \
    --name "SearchAPITarget" \
    --target-configuration '{
        "mcp": {
            "apiGateway": {
                "restApiId": "your-rest-api-id",
                "stage": "your-stage",
                "apiGatewayToolConfiguration": {
                    "toolFilters": [
                        {
                            "filterPath": "/products",
                            "methods": [
                                "GET",
                                "POST"
                            ]
                        }
                    ],
                    "toolOverrides": [
                        {
                            "path": "/products",
                            "method": "GET",
                            "name": "get_items",
                            "description": "Gets information for items in the list of products."
                        }
                    ]
                }
            }
        }
    }'
    --credential-provider-configurations '[
        {
            "credentialProviderType": "GATEWAY_IAM_ROLE"
        }
    ]'

Boto3

Der folgende Code zeigt, wie das AWS Python-SDK (Boto3) verwendet wird:


import boto3

# Create the client
agentcore_client = boto3.client('bedrock-agentcore-control')

# Create an API gateway REST API target with gateway service role authentication
target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="SearchAPITarget",
    targetConfiguration={
        "mcp": {
            "apiGateway": {
                "restApiId": "your-rest-api-id",
                "stage": "your-stage",
                "apiGatewayToolConfiguration": {
                    "toolFilters": [
                        {
                            "filterPath": "/products",
                            "methods": [
                                "GET",
                                "POST"
                            ]
                        }
                    ],
                    "toolOverrides": [
                        {
                            "path": "/products",
                            "method": "GET",
                            "name": "get_item",
                            "description": "Gets information for a specific item in the product list."
                        }
                    ]
                }
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "GATEWAY_IAM_ROLE"
        }
    ]
)

Interactive

Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals den agentcore Befehl aus, wählen Sie Hinzufügen aus, wählen Sie Gateway Target und dann API Gateway REST API aus:

Der Assistent fordert Sie dann zur Eingabe des Zielnamens, der REST-API-ID, der Phase und der Konfiguration für die ausgehende Autorisierung auf.

Ein OpenAPI-Ziel hinzufügen

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AgentCore CLI

Um ein OpenAPI-Schemaziel hinzuzufügen, führen Sie es agentcore add gateway-target mit der --type open-api-schema Option aus und geben Sie den Pfad zu Ihrer OpenAPI-Spezifikationsdatei an:


agentcore add gateway-target \
  --name MyOpenAPITarget \
  --type open-api-schema \
  --schema path/to/openapi-spec.json \
  --outbound-auth none|api-key|oauth \
  --gateway MyGateway
agentcore deploy

Boto3

Der folgende Python-Code zeigt, wie ein OpenAPI-Ziel mithilfe des AWS Python-SDK (Boto3) hinzugefügt wird. Das Schema wurde an einen S3-Speicherort hochgeladen, auf dessen URI in der verwiesen wird. target_payload Die ausgehende Autorisierung für das Ziel erfolgt über einen API-Schlüssel.


import boto3

# Create the client
agentcore_client = boto3.client('bedrock-agentcore-control')

# Create an OpenAPI target with API Key authentication
target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="SearchAPITarget",
    targetConfiguration={
        "mcp": {
            "openApiSchema": {
                "s3": {
                    "uri": "s3://your-bucket/path/to/open-api-spec.json",
                    "bucketOwnerAccountId": "123456789012"
                }
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "API_KEY",
            "credentialProvider": {
                "apiKeyCredentialProvider": {
                    "providerArn": "arn:aws:agent-credential-provider:us-east-1:123456789012:token-vault/default/apikeycredentialprovider/abcdefghijk",
                    "credentialLocation": "HEADER",
                    "credentialParameterName": "X-API-Key"
                }
            }
        }
    ]
)

Interactive

Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals agentcore Folgendes aus, wählen Sie Hinzufügen aus, wählen Sie Gateway Target und dann OpenAPI-Schema aus:

Der Assistent fordert Sie dann auf, den Zielnamen, den Pfad zur OpenAPI-Spezifikationsdatei und die Konfiguration der ausgehenden Autorisierung einzugeben.

Fügen Sie ein Smithy-Ziel hinzu

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AgentCore CLI

Um ein Smithy-Modellziel hinzuzufügen, führen Sie es agentcore add gateway-target mit der --type smithy-model Option aus und geben Sie den Pfad zu Ihrer Smithy-Modelldatei an:
```
agentcore add gateway-target \
  --name MySmithyTarget \
  --type smithy-model \
  --schema path/to/smithy-model.json \
  --gateway MyGateway
agentcore deploy
```

Boto3

Der folgende Python-Code zeigt, wie Sie mithilfe des AWS Python-SDK (Boto3) ein Smithy-Modellziel hinzufügen:


import boto3

# Create the agentcore client
agentcore_client = boto3.client('bedrock-agentcore-control')

# Create a Smithy model target
target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="DynamoDBTarget",
    targetConfiguration={
        "mcp": {
            "smithyModel": {
                "s3": {
                    "uri": "s3://your-bucket/path/to/smithy-model.json",
                    "bucketOwnerAccountId": "123456789012"
                }
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "GATEWAY_IAM_ROLE"
        }
    ]
)

Interactive

Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals den agentcore Befehl aus, wählen Sie Hinzufügen, wählen Sie Gateway Target und dann Smithy Model aus:

Der Assistent fordert Sie dann zur Eingabe des Zielnamens, des Pfads zur Smithy-Modelldatei und der Konfiguration für die ausgehende Autorisierung auf.

Fügen Sie ein HTTP-Laufzeitziel hinzu

Sie können Ihrem Gateway einen Amazon Bedrock AgentCore Runtime-Agenten als HTTP-Ziel hinzufügen. Das Gateway sendet den Datenverkehr ohne Aggregation oder Protokollübersetzung direkt an den Runtime-Agenten.

Weitere Informationen zu HTTP-Zielen finden Sie unter Amazon Bedrock AgentCore Runtime-Ziele.

Wählen Sie eine der folgenden Methoden aus:

Beispiel

Fügen Sie ein MCP-Serverziel hinzu

Sie können ein MCP-Serverziel mithilfe der AgentCore CLI oder des AWS Python-SDK (Boto3) hinzufügen. Die folgenden Beispiele zeigen, wie Sie ein MCP-Serverziel mit unterschiedlichen Typen der ausgehenden Autorisierung erstellen.

MCP-Server mit IAM-Autorisierung (SigV4)

Im folgenden Beispiel wird ein MCP-Serverziel mit IAM-Autorisierung erstellt. Das Gateway signiert Anfragen an den MCP-Server mithilfe von SigV4 mit den Anmeldeinformationen der Gateway-Dienstrolle. Sie müssen den service Namen für das Signieren angeben. Das region ist optional und ist standardmäßig auf die Region des Gateways eingestellt.

Der Wert von service hängt davon ab, wo Ihr MCP-Server gehostet wird. Die folgenden Werte sind gebräuchlich:

bedrock-agentcore— Für MCP-Server, die auf Amazon Bedrock gehostet werden AgentCore, z. B. Runtime (siehe Bereitstellen von MCP-Servern in AgentCore Runtime) oder ein anderes Gateway.
execute-api— Für MCP-Server hinter Amazon API Gateway.
lambda— Für MCP-Server hinter Lambda-Funktions-URLs.

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AWS CLI


aws bedrock-agentcore-control create-gateway-target \
    --gateway-identifier "your-gateway-id" \
    --name "MyMCPTarget" \
    --target-configuration '{
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-server.bedrock-agentcore.us-west-2.api.aws"
            }
        }
    }' \
    --credential-provider-configurations '[{
        "credentialProviderType": "GATEWAY_IAM_ROLE",
        "credentialProvider": {
            "iamCredentialProvider": {
                "service": "bedrock-agentcore",
                "region": "us-west-2"
            }
        }
    }]'

Interactive

Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Folgendes ausagentcore, wählen Sie Hinzufügen aus, wählen Sie Gateway Target und dann MCP Server-Endpunkt aus:

Der Assistent fordert Sie dann zur Eingabe des Zielnamens, der URL des MCP-Serverendpunkts und der Konfiguration für die ausgehende Autorisierung auf.

Boto3


import boto3

agentcore_client = boto3.client('bedrock-agentcore-control')

target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="MyMCPTarget",
    targetConfiguration={
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-server.bedrock-agentcore.us-west-2.api.aws"
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "GATEWAY_IAM_ROLE",
            "credentialProvider": {
                "iamCredentialProvider": {
                    "service": "bedrock-agentcore",
                    "region": "us-west-2"
                }
            }
        }
    ]
)

MCP-Server mit OAuth-Autorisierung

Im folgenden Beispiel wird ein MCP-Serverziel mit OAuth-Autorisierung (Client-Anmeldeinformationen) erstellt.

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AWS CLI


aws bedrock-agentcore-control create-gateway-target \
    --gateway-identifier "your-gateway-id" \
    --name "MyMCPTarget" \
    --target-configuration '{
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-mcp-server.example.com"
            }
        }
    }' \
    --credential-provider-configurations '[{
        "credentialProviderType": "OAUTH",
        "credentialProvider": {
            "oauthCredentialProvider": {
                "providerArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:token-vault/default/oauth2credentialprovider/my-oauth-provider",
                "scopes": []
            }
        }
    }]'

AgentCore CLI

Um ein MCP-Serverziel mit OAuth-Autorisierung hinzuzufügen, führen Sie es agentcore add gateway-target mit der --type mcp-server Option aus und geben Sie die OAuth-Anmeldeinformationen an:


agentcore add gateway-target \
  --type mcp-server \
  --name MyMCPTarget \
  --endpoint https://my-mcp-server.example.com \
  --gateway MyGateway \
  --outbound-auth oauth \
  --oauth-client-id my-client \
  --oauth-client-secret my-secret \
  --oauth-discovery-url https://auth.example.com/.well-known/openid-configuration
agentcore deploy

Boto3


import boto3

agentcore_client = boto3.client('bedrock-agentcore-control')

target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="MyMCPTarget",
    targetConfiguration={
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-mcp-server.example.com"
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "OAUTH",
            "credentialProvider": {
                "oauthCredentialProvider": {
                    "providerArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:token-vault/default/oauth2credentialprovider/my-oauth-provider",
                    "scopes": []
                }
            }
        }
    ]
)

MCP-Server mit API-Schlüsselautorisierung

Im folgenden Beispiel wird ein MCP-Serverziel mit API-Schlüsselautorisierung erstellt.

Wählen Sie eine der folgenden Methoden aus:

Beispiel

AWS CLI


aws bedrock-agentcore-control create-gateway-target \
    --gateway-identifier "your-gateway-id" \
    --name "MyMCPTarget" \
    --target-configuration '{
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-mcp-server.example.com"
            }
        }
    }' \
    --credential-provider-configurations '[{
        "credentialProviderType": "API_KEY",
        "credentialProvider": {
            "apiKeyCredentialProvider": {
                "providerArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:token-vault/default/apikeycredentialprovider/my-api-key",
                "credentialLocation": "HEADER",
                "credentialParameterName": "x-api-key",
                "credentialPrefix": ""
            }
        }
    }]'

Boto3


import boto3

agentcore_client = boto3.client('bedrock-agentcore-control')

target = agentcore_client.create_gateway_target(
    gatewayIdentifier="your-gateway-id",
    name="MyMCPTarget",
    targetConfiguration={
        "mcp": {
            "mcpServer": {
                "endpoint": "https://my-mcp-server.example.com"
            }
        }
    },
    credentialProviderConfigurations=[
        {
            "credentialProviderType": "API_KEY",
            "credentialProvider": {
                "apiKeyCredentialProvider": {
                    "providerArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:token-vault/default/apikeycredentialprovider/my-api-key",
                    "credentialLocation": "HEADER",
                    "credentialParameterName": "x-api-key",
                    "credentialPrefix": ""
                }
            }
        }
    ]
)

Fügen Sie ein Connector-Ziel mit Amazon Bedrock Managed Knowledge Bases hinzu

Sie können den Amazon Bedrock Managed Knowledge Bases-Connector als Ziel zu Ihrem Gateway hinzufügen.

Weitere Informationen zum Amazon Bedrock Managed Knowledge Bases-Konnektor finden Sie unter Amazon Bedrock Managed Knowledge Bases.

Richten Sie eine verwaltete Wissensdatenbank ein

Der Konnektor stellt zwei Tools zur Verfügung, die jeweils nach ihrem Backend-Betrieb benannt sind: AgenticRetrieveStream (mehrstufiger, durch Streaming agentischer Abruf) und Retrieve (eine einzelne Hybridsuche). Sie fügen pro Tool einen Konfigurationseintrag hinzu.

FürAgenticRetrieveStream, legen Sie fest retrievers (die verwalteten Wissensdatenbanken, die abgefragt werden sollen) und agenticRetrieveConfiguration inparameterValues. Beides ist erforderlich — das Auslassen agenticRetrieveConfiguration führt zu einem Laufzeitfehler. Es kann sich um ein leeres Objekt ({}) handeln, das vom Service verwaltete Standardwerte akzeptiert, aber wenn die Konfiguration angegeben wird, rerankingModelType wird sie foundationModelType explizit. Der Agent stellt beim Anruf keine Knowledge-Base-IDs bereit. Geben Sie Retrieve das knowledgeBaseId Feld für einparameterValues; es ist erforderlich.

Der Konnektor unterstützt nur verwaltete Wissensdatenbanken. Connector-Ziele unterstützen nur den GATEWAY_IAM_ROLE Anmeldeinformationsanbietertyp.

Beispiel

Boto3

Der folgende Python-Code zeigt, wie Sie mithilfe des AWS Python SDK (Boto3) ein Gateway-Ziel mit der Amazon Bedrock Managed Knowledge Bases-Konnektorkonfiguration erstellen:


import boto3

gateway_client = boto3.client("bedrock-agentcore-control", region_name="<REGION>")

gateway_client.create_gateway_target(
    name="managed-kb",
    gatewayIdentifier="<GATEWAY_ID>",
    targetConfiguration={
        "mcp": {
            "connector": {
                "source": {"connectorId": "bedrock-knowledge-bases"},
                "configurations": [
                    {
                        "name": "AgenticRetrieveStream",
                        "parameterValues": {
                            "retrievers": [
                                {
                                    "description": "Product documentation",
                                    "configuration": {"knowledgeBase": {"knowledgeBaseId": "<KB_ID_1>"}},
                                },
                                {
                                    "description": "Engineering runbooks",
                                    "configuration": {"knowledgeBase": {"knowledgeBaseId": "<KB_ID_2>"}},
                                },
                            ],
                            "agenticRetrieveConfiguration": {
                                "foundationModelType": "MANAGED",
                                "rerankingModelType": "MANAGED",
                            },
                        },
                    },
                    {
                        "name": "Retrieve",
                        "parameterValues": {"knowledgeBaseId": "<KB_ID>"},
                    },
                ],
            }
        }
    },
    credentialProviderConfigurations=[
        {"credentialProviderType": "GATEWAY_IAM_ROLE"}
    ],
)

AWS CLI

Der folgende Befehl erstellt mithilfe der AWS CLI ein Gateway-Ziel mit der Amazon Bedrock Managed Knowledge Bases-Konnektorkonfiguration:


aws bedrock-agentcore-control create-gateway-target \
  --gateway-identifier "<GATEWAY_ID>" \
  --name "managed-kb" \
  --target-configuration '{
    "mcp": {
      "connector": {
        "source": {
          "connectorId": "bedrock-knowledge-bases"
        },
        "configurations": [
          {
            "name": "AgenticRetrieveStream",
            "parameterValues": {
              "retrievers": [
                {
                  "description": "Product documentation",
                  "configuration": {"knowledgeBase": {"knowledgeBaseId": "<KB_ID_1>"}}
                },
                {
                  "description": "Engineering runbooks",
                  "configuration": {"knowledgeBase": {"knowledgeBaseId": "<KB_ID_2>"}}
                }
              ],
              "agenticRetrieveConfiguration": {
                "foundationModelType": "MANAGED",
                "rerankingModelType": "MANAGED"
              }
            }
          },
          {
            "name": "Retrieve",
            "parameterValues": {
              "knowledgeBaseId": "<KB_ID>"
            }
          }
        ]
      }
    }
  }' \
  --credential-provider-configurations '[{"credentialProviderType": "GATEWAY_IAM_ROLE"}]' \
  --region "<REGION>"

AgentCore CLI

Um ein verwaltetes Knowledge Base-Connector-Ziel hinzuzufügen, führen Sie Folgendes ausagentcore add gateway-target: --type connector --connector bedrock-knowledge-bases


agentcore add gateway-target \
  --name MyKnowledgeBaseTarget \
  --type connector \
  --connector bedrock-knowledge-bases \
  --knowledge-base-id <KB_ID> \
  --gateway MyGateway
agentcore deploy

Interactive

Führen agentcore add gateway-target Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Amazon Bedrock Knowledge Bases aus und wählen Sie anschließend Amazon Bedrock Knowledge Bases aus der Zieltypauswahl aus:

Der Assistent fordert Sie zur Eingabe eines Namens und einer Beschreibung auf und ermöglicht Ihnen, einen oder mehrere Quelltypen und Quellen auszuwählen.

Nach Ihrem Anruf CreateGatewayTarget validiert das Gateway die Konfiguration asynchron (normalerweise innerhalb von etwa 30 Sekunden), was eine GetKnowledgeBase Überprüfung jeder gebundenen Wissensdatenbank beinhaltet. Umfrage GetGatewayTarget bis status istREADY; ein FAILED Status enthält einen Grund, der das Problem beschreibt.

Fügen Sie die optionalen Felder hinzu, um den Agentenabruf zu personalisieren — z. B. um Planungsiterationen zu begrenzen oder eine Leitplanke hinzuzufügen. agenticRetrieveConfiguration Wenn Sie sie weglassen, gelten die vom Service verwalteten Standardeinstellungen. Alle akzeptierten Werte finden Sie in der Konfigurationsreferenz.


{
  "name": "AgenticRetrieveStream",
  "parameterValues": {
    "retrievers": [
      { "configuration": { "knowledgeBase": { "knowledgeBaseId": "<KB_ID>" } } }
    ],
    "agenticRetrieveConfiguration": {
      "maxAgentIteration": 5,
      "policyConfiguration": {
        "guardrailConfiguration": {
          "guardrailId": "<GUARDRAIL_ID>",
          "guardrailVersion": "1"
        }
      }
    }
  }
}

Steuern Sie, welche Parameter der Agent festlegen kann

Jeder Eintrag in der Tool-Konfiguration akzeptiert zwei Parametersteuerungen, die bestimmen, was der aufrufende Agent sieht und was das Gateway an die Wissensdatenbank sendet:

parameterValues— vom Administrator festgelegte Werte, die bei jedem Anruf an die Wissensdatenbank gesendet werden, z. B. der gebundene Wert knowledgeBaseId oder der Standardwert. numberOfResults Diese werden verwendet, es sei denn, der Agent überschreibt ein Feld, das Sie verfügbar gemacht haben.
parameterOverrides— eine Liste, die steuert, welche Anforderungsfelder der Agent zum Zeitpunkt des Anrufs sehen und einstellen kann. Jeder Eintrag hat:
- path— das Feld in der Retrieve Anfrage, zum Beispiel $.retrievalQuery.text oder$.retrievalConfiguration.managedSearchConfiguration.numberOfResults.
- description— optionaler Text, der dem Agenten angezeigt wird und der das Feld beschreibt.
- visible— so eingestellt, true dass das Feld für den Agenten sichtbar ist oder false dass es ausgeblendet wird, während alle vom Administrator konfigurierten Standardeinstellungen weiterhin gesendet werden.

Binden Sie knowledgeBaseId es ein parameterValues und legen Sie es nicht offen.

Der folgende Konfigurationseintrag bindet die Wissensdatenbank, legt einen Standardwert von 10 Ergebnissen fest und macht den Abfragetext und die Anzahl der Ergebnisse für den Agenten verfügbar:


{
  "name": "Retrieve",
  "description": "Search the knowledge base for relevant documents.",
  "parameterValues": {
    "knowledgeBaseId": "<KB_ID>",
    "retrievalConfiguration": {
      "managedSearchConfiguration": {
        "numberOfResults": 10
      }
    }
  },
  "parameterOverrides": [
    {
      "path": "$.retrievalQuery.text",
      "description": "The search query. Use specific keywords for best results.",
      "visible": true
    },
    {
      "path": "$.retrievalConfiguration.managedSearchConfiguration.numberOfResults",
      "description": "Number of results to retrieve (1-100).",
      "visible": true
    }
  ]
}

Konfigurieren Sie die Gateway-Dienstrolle

Dieser Connector verwendet die Gateway-Ausführungsrolle — den ARN für die IAM-Rolle, an den Sie übergebenCreateGateway, und von dem der AgentCore Dienst annimmt, dass er das Backend in Ihrem Namen aufruft. Dies ist eine Rolle, die Sie erstellen, keine dienstbezogene Rolle. Für den Amazon Bedrock Managed Knowledge Bases-Konnektor sind die folgenden Berechtigungen erforderlich:

bedrock:GetKnowledgeBase— um die gebundene Wissensdatenbank bei der Erstellung des Ziels zu validieren. Auf die verwaltete Wissensdatenbank-Ressource beschränkt.
bedrock:Retrieve— für das Tool. Retrieve Auf die verwaltete Wissensdatenbank-Ressource beschränkt.
bedrock:AgenticRetrieveStream— für das Tool. AgenticRetrieveStream Diese Aktion ist nicht auf eine verwaltete Wissensdatenbankressource beschränkt, also gewähren Sie sie. *

Das Gateway signiert die Backend-Aufrufe als Dienst. bedrock Einbeziehen, bedrock:GetKnowledgeBase unabhängig davon, welche Tools Sie hinzufügen. Wenn Sie nur ein Tool hinzufügen, schließen Sie nur die Abrufaktion dieses Tools ein.

Anmerkung

bedrock-agentcore:InvokeGatewayist nicht Teil der Ausführungsrolle. Diese Berechtigung gehört dem Aufrufer — dem Agenten oder der Anwendung, die das Gateway aufruft — und nicht der Rolle, die das Gateway einnimmt.

Fügen Sie der Ausführungsrolle, die dem Gateway zugewiesen ist, eine Richtlinie mit dem folgenden Inhalt hinzu:


{
  "Version": "2012-10-17", 
  "Statement": [
    {
      "Sid": "ValidateKnowledgeBase",
      "Effect": "Allow",
      "Action": "bedrock:GetKnowledgeBase",
      "Resource": "arn:aws:bedrock:<REGION>:<ACCOUNT_ID>:knowledge-base/<KB_ID>"
    },
    {
      "Sid": "RetrieveFromKnowledgeBase",
      "Effect": "Allow",
      "Action": "bedrock:Retrieve",
      "Resource": "arn:aws:bedrock:<REGION>:<ACCOUNT_ID>:knowledge-base/<KB_ID>"
    },
    {
      "Sid": "AgenticRetrieveStream",
      "Effect": "Allow",
      "Action": "bedrock:AgenticRetrieveStream",
      "Resource": "*"
    }
  ]
}

Die Servicerolle muss dem AgentCore Dienst außerdem vertrauen, damit er die Rolle übernehmen kann. Fügen Sie die folgende Vertrauensrichtlinie hinzu und beschränken Sie sie auf Ihr Konto und Gateway mit den entsprechenden Bedingungenaws:SourceAccount: aws:SourceArn


{
  "Version": "2012-10-17", 
  "Statement": [
    {
      "Sid": "AllowAgentCoreToAssumeRole",
      "Effect": "Allow",
      "Principal": {
        "Service": "bedrock-agentcore.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "<ACCOUNT_ID>"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:bedrock-agentcore:<REGION>:<ACCOUNT_ID>:gateway/*"
        }
      }
    }
  ]
}

Fügen Sie mit dem Web Search Tool ein Connector-Ziel hinzu

Sie können Ihrem Gateway einen integrierten Connector als Ziel hinzufügen. Der Web Search Tool-Connector bietet verwaltete Websuchfunktionen, ohne dass eine benutzerdefinierte Infrastruktur oder API-Schlüssel erforderlich sind.

Weitere Informationen zum Web Search Tool-Connector finden Sie unter Web Search Tool.

Richten Sie das Web Search Tool ein

Beispiel

Boto3

Der folgende Python-Code zeigt, wie ein Gateway-Ziel mit der Konnektorkonfiguration des Web Search Tools mithilfe des AWS Python-SDK (Boto3) erstellt wird:


import boto3

gateway_client = boto3.client("bedrock-agentcore-control", region_name="<REGION>")

gateway_client.create_gateway_target(
    name="web-search-tool",
    gatewayIdentifier="<GATEWAY_ID>",
    targetConfiguration={
        "mcp": {
            "connector": {
                "source": {"connectorId": "web-search"},
                "configurations": [{"name": "WebSearch", "parameterValues": {}}],
            }
        }
    },
    credentialProviderConfigurations=[
        {"credentialProviderType": "GATEWAY_IAM_ROLE"}
    ],
)

AWS CLI

Der folgende Befehl erstellt ein Gateway-Ziel mit der Web Search Tool-Connectorkonfiguration mithilfe der AWS CLI:


aws bedrock-agentcore-control create-gateway-target \
  --gateway-identifier "<GATEWAY_ID>" \
  --name "web-search-tool" \
  --target-configuration '{
    "mcp": {
      "connector": {
        "source": {
          "connectorId": "web-search"
        },
        "configurations": [
          {
            "name": "WebSearch",
            "parameterValues": {}
          }
        ]
      }
    }
  }' \
  --credential-provider-configurations '[{"credentialProviderType": "GATEWAY_IAM_ROLE"}]' \
  --region "<REGION>"

AgentCore CLI

Um ein Web Search Tool-Ziel hinzuzufügen, führen Sie Folgendes aus agentcore add gateway-target--type connector --connector web-search:


agentcore add gateway-target \
  --name MyWebSearchTarget \
  --type connector \
  --connector web-search \
  --gateway MyGateway
agentcore deploy

Interactive

Führen agentcore add gateway-target Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Amazon Web Search aus und wählen Sie dann Amazon Web Search aus der Zieltypauswahl aus:

Der Assistent fordert Sie auf, einen Zielnamen, das Gateway, an das eine Verbindung angehängt werden soll, und eine optionale Liste von Domains einzugeben, die aus den Suchergebnissen ausgeschlossen werden sollen.

Konfigurieren Sie die Domänenfilterung

Sie können einschränken, welche Domains das Web Search Tool abfragen darf, indem Sie eine Domain-Denylist konfigurieren. Dies ist nützlich für Administratoren, die verhindern möchten, dass Agenten Ergebnisse von bestimmten Websites zurückgeben.

Die Domänenfilterung wird auf Toolebene mithilfe des parameterValues.domainFilter.exclude Felds konfiguriert, wenn ein Gateway-Ziel erstellt oder aktualisiert wird. Die Denylist wird serverseitig durchgesetzt und ist vor dem LLM verborgen. Der Agent ist sich der Einschränkung nicht bewusst und erhält einfach keine Ergebnisse von ausgeschlossenen Domänen.

In den folgenden Beispielen wird ein Web Search Tool-Ziel mit Domainfilterung erstellt, das Ergebnisse von und ausschließt: blocked-website-1.com blocked-website-2.com

Beispiel

Boto3

Der folgende Python-Code zeigt, wie Sie mithilfe des AWS Python-SDK (Boto3) ein Web Search Tool-Ziel mit Domainfilterung erstellen:


import boto3

gateway_client = boto3.client("bedrock-agentcore-control", region_name="<REGION>")

gateway_client.create_gateway_target(
    name="web-search-tool",
    gatewayIdentifier="<GATEWAY_ID>",
    targetConfiguration={
        "mcp": {
            "connector": {
                "source": {"connectorId": "web-search"},
                "configurations": [
                    {
                        "name": "WebSearch",
                        "parameterValues": {
                            "domainFilter": {
                                "exclude": ["blocked-website-1.com", "blocked-website-2.com"]
                            }
                        },
                    }
                ],
            }
        }
    },
    credentialProviderConfigurations=[
        {"credentialProviderType": "GATEWAY_IAM_ROLE"}
    ],
)

AWS CLI

Der folgende Befehl erstellt ein Web Search Tool-Ziel mit Domainfilterung mithilfe der AWS CLI:


aws bedrock-agentcore-control create-gateway-target \
  --gateway-identifier "<GATEWAY_ID>" \
  --name "web-search-tool" \
  --target-configuration '{
    "mcp": {
      "connector": {
        "source": {
          "connectorId": "web-search"
        },
        "configurations": [
          {
            "name": "WebSearch",
            "parameterValues": {
              "domainFilter": {
                "exclude": ["blocked-website-1.com", "blocked-website-2.com"]
              }
            }
          }
        ]
      }
    }
  }' \
  --credential-provider-configurations '[{"credentialProviderType": "GATEWAY_IAM_ROLE"}]' \
  --region "<REGION>"

AgentCore CLI

Übergeben Sie eine durch Kommas getrennte Liste von Domains über: --exclude-domains


agentcore add gateway-target \
  --name MyWebSearchTarget \
  --type connector \
  --connector web-search \
  --exclude-domains blocked-website-1.com,blocked-website-2.com \
  --gateway MyGateway
agentcore deploy

Interactive

In der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals fordert der Assistent „Gateway-Ziel hinzufügen“ zur Eingabe einer optionalen, durch Kommas getrennten Liste von Domains auf, die aus den Suchergebnissen ausgeschlossen werden sollen, nachdem Sie Amazon Web Search und ein Gateway ausgewählt haben. Wenn Sie die Eingabeaufforderung leer lassen, wird das Ziel ohne Domainfilterung erstellt.

Sie können auch ein vorhandenes Ziel aktualisieren, um die Domänenfilterung mithilfe von hinzuzufügen oder zu ändernUpdateGatewayTarget.

Konfigurieren Sie die Gateway-Dienstrolle

Das Gateway benötigt eine Servicerolle, die es dem AgentCore Dienst ermöglicht, Aktionen in Ihrem Namen auszuführen. Für das Web Search Tool benötigt die Rolle die folgenden Berechtigungen:

bedrock-agentcore:InvokeGateway— um das Gateway aufzurufen
bedrock-agentcore:InvokeWebSearch— um Websuchaufrufe zu autorisieren, die pro Anfrage mit dem diensteigenen ARN abgeglichen werden arn:aws:bedrock-agentcore:<region>:aws:tool/web-search.v1

Fügen Sie der dem Gateway zugewiesenen Servicerolle eine Richtlinie mit dem folgenden Inhalt hinzu:


{
  "Version": "2012-10-17", 
  "Statement": [
    {
      "Sid": "InvokeGateway",
      "Effect": "Allow",
      "Action": "bedrock-agentcore:InvokeGateway",
      "Resource": "arn:aws:bedrock-agentcore:<REGION>:<ACCOUNT_ID>:gateway/*"
    },
    {
      "Sid": "InvokeWebSearch",
      "Effect": "Allow",
      "Action": "bedrock-agentcore:InvokeWebSearch",
      "Resource": "arn:aws:bedrock-agentcore:<REGION>:aws:tool/web-search.v1"
    }
  ]
}

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

Geben Sie den Autorisierungstyp und die Anmeldeinformationen an

Verwenden Sie ein Gateway