

# Verwenden des Registry MCP-Endpunkts
<a name="registry-mcp-endpoint"></a>

**Bevorstehende Namespace-Migration**  
 AWS Agent Registry befindet sich derzeit in der öffentlichen Vorschauversion unter dem Bedrock-Agentcore-Namespace. Ab dem 6. August 2026 wird der Dienst in den Agent-Registry-Namespace verschoben. Wenn Sie AWS Agent Registry verwenden, müssen Sie Ihre Endpoints, IAM-Richtlinien, SDK-Clients, CLI-Skripts und Registrierungsdaten aktualisieren. Weitere Informationen zur Migration aus der öffentlichen Vorschauversion finden Sie unter [Umfassender Anleitung zur Registrierungsmigration](registry-faq.md).

## -Übersicht
<a name="registry-mcp-overview"></a>

Jede Registrierung stellt einen MCP-compatible Endpunkt bereit, der der Spezifikation [2025-11-25 entspricht](https://modelcontextprotocol.io/specification/2025-11-25). Der Endpunkt unterstützt die Auflistung von Tools und den Aufruf von Tools zum Durchsuchen von Registrierungseinträgen.

```
https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp
```

Das MCP enthält ein Tool namens „search\_registry\_records“.

```
Tool name: search_registry_records

Description:
Searches for registry records using natural language queries. Returns metadata for matching records.

Parameters:
- searchQuery (required): string - Natural language search query
- maxResults: integer - Maximum number of results to return (1-20, default 10)
- filter: object - Optional metadata filter using structured JSON operators. Supports field-level operators ($eq, $ne,
  $in) and logical operators ($and, $or) on filterable fields (name, descriptorType, version). Example:
  {"descriptorType": {"$eq": "MCP"}}
```

Sie können von einem vorhandenen MCP-Client wie Kiro, Claude usw. aus eine Verbindung zur Registrierung herstellen.

## Stellen Sie von einem vorhandenen MCP-Client aus eine Connect zum OAuth-based Registrierungs-MCP-Endpunkt her
<a name="registry-mcp-connect-oauth"></a>

### Berechtigungen
<a name="registry-mcp-permissions-oauth"></a>

Der MCP-Endpunkt verwendet dasselbe, um die eingehenden Anfragen **CustomJWTAuthorizerConfiguration**zu autorisieren.

Der `.well-known/oauth-protected-resource` Pfad ist:. `https://bedrock-agentcore.<region>.amazonaws.com/.well-known/oauth-protected-resource/registry/<registryId>/mcp`

Der Client kann die Metadaten auch aus dem `WWW-Authenticate` Header ermitteln:

```
www-authenticate: Bearer resource_metadata="https://bedrock-agentcore.<region>.amazonaws.com/.well-known/oauth-protected-resource/registry/<registryId>/mcp"
```

Sobald Sie das Zugriffstoken erhalten haben, können Sie es validieren:

```
curl -s -X POST "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"search_registry_records","arguments":{"searchQuery":"weather"}}}'
```

Abhängig von Ihrem Autorisierungsserver und den Sicherheitsanforderungen Ihres Unternehmens können Sie einen der folgenden Ansätze wählen, um Ihren MCP-Client zu konfigurieren:

1. Bearer-Token: Verwenden Sie einen separaten Prozess, um das Bearer-Token abzurufen und es im MCP-Client-Header zu konfigurieren

1. Pre-registered Client: Erstellen Sie einen Client auf Ihrem Autorisierungsserver und setzen Sie den Client in der Konfiguration der Registrierung auf die Zulassungsliste.

1. Dynamische Client-Registrierung: Wenn Ihr Autorisierungsserver die dynamische Client-Registrierung (DCR) unterstützt, können Sie die Zielgruppe in der Konfiguration der Registrierung zulassen.

### OAuth-based Einrichtung des MCP-Clients
<a name="registry-mcp-connect-oauth-setup"></a>

#### Verwenden Sie das Inhaber-Token
<a name="registry-mcp-connect-oauth-bearer"></a>

In den meisten IDEs können Sie das Bearer-Token für den Autorisierungsheader in einer MCP-Konfiguration konfigurieren. [Kiro unterstützt](https://kiro.dev/blog/introducing-remote-mcp/#securing-mcp-connections) beispielsweise Umgebungsvariablen mithilfe der Syntax. `${ENV_VAR}` Sie können das folgende Beispiel verwenden:

```
{
  "mcpServers": {
    "my-registry": {
      "type": "http",
      "url": "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp",
      "headers": {
        "Authorization": "Bearer ${ACCESS_TOKEN}"
      }
    }
  }
}
```

#### Pre-registered Kunde
<a name="registry-mcp-connect-oauth-preregistered"></a>

Sie können einen neuen Client auf der Grundlage der Erteilung des Autorisierungscodes auf Ihrem Autorisierungsserver erstellen und den Client für den Zugriff auf die Registrierung verwenden. [Erstellen Sie beispielsweise einen Client im Cognito-Benutzerpool](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/identity-idp-cognito.html).

Sobald Sie die Client-ID haben, stellen Sie sicher, dass Sie sie in der Registrierung zulassen:

```
aws bedrock-agentcore-control update-registry \
  --registry-id <registryId> \
  --authorizer-configuration '{
    "optionalValue": {
      "customJWTAuthorizer": {
        "discoveryUrl": "https://<example-domain>/.well-known/openid-configuration",
        "allowedClients": ["<client-id>"]
      }
    }
  }'
```

Dann können Sie Ihren MCP-Client konfigurieren, wenn er die Angabe von clientId unterstützt. Ein Beispiel im Claude-Code:

```
{
  "mcpServers": {
    "pre-registered-registry": {
      "type": "http",
      "url": "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp",
      "oauth": {
        "clientId": "<client-id>",
        "callbackPort": "<port-number>"
      }
    }
  }
}
```

**Anmerkung**  
Bei einigen Autorisierungsservern wie Auth0 und Cognito können Sie eine Reihe von Ports nicht als zulässige Umleitungs-URIs konfigurieren. Daher müssen Sie einen Port explizit in der zulässigen redirect/callback URL des vorregistrierten Clients sowie in der mcp.json festlegen.

#### Dynamische Client-Registrierung
<a name="registry-mcp-connect-oauth-dcr"></a>

Die meisten MCP-Client-Anwendungen unterstützen die dynamische Client-Registrierung. In diesem Fall sollten Sie KEINEN `allowedClients` Wert in der Registrierung angeben. Stattdessen können Sie wählen, ob Sie festlegen möchten`allowedAudience`. Der Wert kann mit Ihrer MCP-Registrierung identisch sein. Sie sollten Ihren Autorisierungsserver so konfigurieren, dass er JWT mit einem `aud` Feld ausgibt, das denselben Wert wie in hat. `allowedAudience`

```
aws bedrock-agentcore-control update-registry \
  --registry-id <registryId> \
  --authorizer-configuration '{
    "optionalValue": {
      "customJWTAuthorizer": {
        "discoveryUrl": "https://<example-domain>/.well-known/openid-configuration",
        "allowedAudience": ["https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp"]
      }
    }
  }'
```

Dann können Sie Ihren MCP-Client einfach über eine URL konfigurieren:

```
{
  "mcpServers": {
    "dcr-registry": {
      "type": "http",
      "url": "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp"
    }
  }
}
```

Häufige Fehler bei der Einrichtung der dynamischen Client-Registrierung:
+ Sie müssen sicherstellen, dass der Autorisierungsserver die dynamische Clientregistrierung unterstützt.
+ Der Autorisierungsserver muss JWT mit einem `aud` Feld ausgeben, das in Ihrer Registrierung zulässig ist CustomJWTAuthorizerConfiguration.
+ Derzeit gibt die Registrierung keine Scope-Abfrage im WWW-Authenticate-Header zurück. [Einige MCP-Clients unterstützen die explizite Definition `oauthScopes` in der Konfiguration, z. B. Kiro.](https://kiro.dev/docs/cli/custom-agents/configuration-reference/#oauth-configuration)

## Stellen Sie von einem vorhandenen MCP-Client aus eine Connect zum IAM-based Registrierungs-MCP-Endpunkt her
<a name="registry-mcp-connect-iam"></a>

### Berechtigungen
<a name="registry-mcp-permissions-iam"></a>

Für die MCP-Initialisierung und die Auflistung der Tools:

```
{
    "Effect": "Allow",
    "Action": "bedrock-agentcore:InvokeRegistryMcp",
    "Resource": "arn:aws:bedrock-agentcore:*:<account>:registry/*"
}
```

Für die Suche per MCP-Tool-Aufruf benötigen Sie außerdem:

```
{
    "Effect": "Allow",
    "Action":
    [
        "bedrock-agentcore:InvokeRegistryMcp",
        "bedrock-agentcore:SearchRegistryRecords"
    ],
    "Resource": "arn:aws:bedrock-agentcore:*:<account>:registry/*"
}
```

Sie können die Erlaubnis mit dem folgenden Befehl überprüfen:

```
curl -s -X POST "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp" \
  -H "Content-Type: application/json" \
  -H "X-Amz-Security-Token: ${AWS_SESSION_TOKEN}" \
  --aws-sigv4 "aws:amz:<region>:bedrock-agentcore" \
  --user "${AWS_ACCESS_KEY_ID}:${AWS_SECRET_ACCESS_KEY}" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"search_registry_records","arguments":{"searchQuery":"weather"}}}'
```

### IAM-based MCP-Client-Setup
<a name="registry-mcp-connect-iam-setup"></a>

Sie können [mcp-proxy-for-aws](https://github.com/aws/mcp-proxy-for-aws) verwenden, um eine Verbindung zu einer Registrierung herzustellen. IAM-based Zum Beispiel in Kiro mcp.json:

```
{
  "mcpServers": {
    "iam-based-registry": {
      "disabled": false,
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://bedrock-agentcore.<region>.amazonaws.com/registry/<registryId>/mcp",
        "--service",
        "bedrock-agentcore",
        "--region",
        "<region>",
        "--profile",
        "my-profile"
      ]
    }
  }
}
```

## Entwickeln Sie Ihren eigenen MCP-Client
<a name="registry-mcp-develop-client"></a>

Weitere Code-Referenzen zum Aufrufen des Registry MCP-Endpunkts, auch von beliebten IDEs wie Kiro oder Claude Code, finden Sie in den Beispielcode-Referenzen im öffentlichen Code-Repository.