# 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](gateway-supported-targets.md).
Wählen Sie ein Thema aus, um Beispiele für das Hinzufügen eines Zieltyps zu sehen:
**Topics**
+ [Ein Lambda-Ziel hinzufügen](#gateway-add-target-api-lambda)
+ [Ein API-Gateway-Phasenziel hinzufügen](#gateway-add-target-api-gateway)
+ [Ein OpenAPI-Ziel hinzufügen](#gateway-add-target-api-openapi)
+ [Fügen Sie ein Smithy-Ziel hinzu](#gateway-add-target-api-smithy)
+ [Fügen Sie ein HTTP-Laufzeitziel hinzu](#gateway-add-target-api-http-runtime)
+ [Fügen Sie ein MCP-Serverziel hinzu](#gateway-add-target-api-MCPserver)
+ [Fügen Sie ein Connector-Ziel mit Amazon Bedrock Managed Knowledge Bases hinzu](#gateway-add-target-api-connector-managed-kb)
+ [Fügen Sie mit dem Web Search Tool ein Connector-Ziel hinzu](#gateway-add-target-api-connector-web-search)
## 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](gateway-add-target-lambda.md).
Wählen Sie eine der folgenden Methoden aus:
**Example**
1. 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
```
1. 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": "",
"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"
]
}
}
]
}
}
```
1. 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"
}
]
)
```
1. Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Folgendes aus`agentcore`, 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:
**Example**
1. 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
```
1. 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"
}
]'
```
1. 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"
}
]
)
```
1. 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:
**Example**
1. 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
```
1. 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"
}
}
}
]
)
```
1. 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:
**Example**
1. 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
```
1. 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"
}
]
)
```
1. 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](gateway-target-http-runtime.md).
Wählen Sie eine der folgenden Methoden aus:
**Example**
1. Der folgende Befehl erstellt ein HTTP-Laufzeitziel mit IAM-Autorisierung:
```
aws bedrock-agentcore-control create-gateway-target \
--gateway-identifier "your-gateway-id" \
--name "MyRuntimeTarget" \
--description "Runtime gateway target" \
--target-configuration '{
"http": {
"agentcoreRuntime": {
"arn": "arn:aws:bedrock-agentcore:us-west-2:111122223333:runtime/RUNTIME_ID"
}
}
}' \
--credential-provider-configurations '[{
"credentialProviderType": "GATEWAY_IAM_ROLE"
}]'
```
1. Der folgende Python-Code zeigt, wie ein HTTP-Laufzeitziel mithilfe des AWS Python-SDK (Boto3) hinzugefügt wird:
```
import boto3
agentcore_client = boto3.client('bedrock-agentcore-control')
target = agentcore_client.create_gateway_target(
gatewayIdentifier="your-gateway-id",
name="MyRuntimeTarget",
description="Runtime gateway target",
targetConfiguration={
"http": {
"agentcoreRuntime": {
"arn": "arn:aws:bedrock-agentcore:us-west-2:111122223333:runtime/RUNTIME_ID"
}
}
},
credentialProviderConfigurations=[
{
"credentialProviderType": "GATEWAY_IAM_ROLE"
}
]
)
```
## 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](runtime-mcp.md)) 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:
**Example**
1.
```
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"
}
}
}]'
```
1. Führen Sie in der Benutzeroberfläche des interaktiven AgentCore CLI-Terminals Folgendes aus`agentcore`, 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.
1.
```
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:
**Example**
1.
```
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": []
}
}
}]'
```
1. 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
```
1.
```
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:
**Example**
1.
```
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": ""
}
}
}]'
```
1.
```
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](gateway-target-connector-managed-kb.md) 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ür`AgenticRetrieveStream`, legen Sie fest `retrievers` (die verwalteten Wissensdatenbanken, die abgefragt werden sollen) und `agenticRetrieveConfiguration` in`parameterValues`. 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 ein`parameterValues`; es ist erforderlich.
Der Konnektor unterstützt nur verwaltete Wissensdatenbanken. Connector-Ziele unterstützen nur den `GATEWAY_IAM_ROLE` Anmeldeinformationsanbietertyp.
**Example**
1. 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="")
gateway_client.create_gateway_target(
name="managed-kb",
gatewayIdentifier="",
targetConfiguration={
"mcp": {
"connector": {
"source": {"connectorId": "bedrock-knowledge-bases"},
"configurations": [
{
"name": "AgenticRetrieveStream",
"parameterValues": {
"retrievers": [
{
"description": "Product documentation",
"configuration": {"knowledgeBase": {"knowledgeBaseId": ""}},
},
{
"description": "Engineering runbooks",
"configuration": {"knowledgeBase": {"knowledgeBaseId": ""}},
},
],
"agenticRetrieveConfiguration": {
"foundationModelType": "MANAGED",
"rerankingModelType": "MANAGED",
},
},
},
{
"name": "Retrieve",
"parameterValues": {"knowledgeBaseId": ""},
},
],
}
}
},
credentialProviderConfigurations=[
{"credentialProviderType": "GATEWAY_IAM_ROLE"}
],
)
```
1. 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 "" \
--name "managed-kb" \
--target-configuration '{
"mcp": {
"connector": {
"source": {
"connectorId": "bedrock-knowledge-bases"
},
"configurations": [
{
"name": "AgenticRetrieveStream",
"parameterValues": {
"retrievers": [
{
"description": "Product documentation",
"configuration": {"knowledgeBase": {"knowledgeBaseId": ""}}
},
{
"description": "Engineering runbooks",
"configuration": {"knowledgeBase": {"knowledgeBaseId": ""}}
}
],
"agenticRetrieveConfiguration": {
"foundationModelType": "MANAGED",
"rerankingModelType": "MANAGED"
}
}
},
{
"name": "Retrieve",
"parameterValues": {
"knowledgeBaseId": ""
}
}
]
}
}
}' \
--credential-provider-configurations '[{"credentialProviderType": "GATEWAY_IAM_ROLE"}]' \
--region ""
```
1. Um ein verwaltetes Knowledge Base-Connector-Ziel hinzuzufügen, führen Sie Folgendes aus`agentcore add gateway-target`: `--type connector --connector bedrock-knowledge-bases`
```
agentcore add gateway-target \
--name MyKnowledgeBaseTarget \
--type connector \
--connector bedrock-knowledge-bases \
--knowledge-base-id \
--gateway MyGateway
agentcore deploy
```
1. 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` ist`READY`; 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.](gateway-target-connector-managed-kb.md#gateway-target-connector-managed-kb-config-reference)
```
{
"name": "AgenticRetrieveStream",
"parameterValues": {
"retrievers": [
{ "configuration": { "knowledgeBase": { "knowledgeBaseId": "" } } }
],
"agenticRetrieveConfiguration": {
"maxAgentIteration": 5,
"policyConfiguration": {
"guardrailConfiguration": {
"guardrailId": "",
"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": "",
"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 übergeben`CreateGateway`, 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:InvokeGateway`ist 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:::knowledge-base/"
},
{
"Sid": "RetrieveFromKnowledgeBase",
"Effect": "Allow",
"Action": "bedrock:Retrieve",
"Resource": "arn:aws:bedrock:::knowledge-base/"
},
{
"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 Bedingungen`aws: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": ""
},
"ArnLike": {
"aws:SourceArn": "arn:aws:bedrock-agentcore:::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](gateway-target-connector-web-search-tool.md).
### Richten Sie das Web Search Tool ein
**Example**
1. 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="")
gateway_client.create_gateway_target(
name="web-search-tool",
gatewayIdentifier="",
targetConfiguration={
"mcp": {
"connector": {
"source": {"connectorId": "web-search"},
"configurations": [{"name": "WebSearch", "parameterValues": {}}],
}
}
},
credentialProviderConfigurations=[
{"credentialProviderType": "GATEWAY_IAM_ROLE"}
],
)
```
1. 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 "" \
--name "web-search-tool" \
--target-configuration '{
"mcp": {
"connector": {
"source": {
"connectorId": "web-search"
},
"configurations": [
{
"name": "WebSearch",
"parameterValues": {}
}
]
}
}
}' \
--credential-provider-configurations '[{"credentialProviderType": "GATEWAY_IAM_ROLE"}]' \
--region ""
```
1. 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
```
1. 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`
**Example**
1. 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="")
gateway_client.create_gateway_target(
name="web-search-tool",
gatewayIdentifier="",
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"}
],
)
```
1. Der folgende Befehl erstellt ein Web Search Tool-Ziel mit Domainfilterung mithilfe der AWS CLI:
```
aws bedrock-agentcore-control create-gateway-target \
--gateway-identifier "" \
--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 ""
```
1. Ü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
```
1. 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 ändern`UpdateGatewayTarget`.
### 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::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:::gateway/*"
},
{
"Sid": "InvokeWebSearch",
"Effect": "Allow",
"Action": "bedrock-agentcore:InvokeWebSearch",
"Resource": "arn:aws:bedrock-agentcore::aws:tool/web-search.v1"
}
]
}
```