Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exemples

Les exemples suivants présentent les fonctions AWS Lambda de Python pour les cas d'utilisation courants des intercepteurs.

Pass-through intercepteur

Cet exemple illustre un intercepteur simple qui enregistre la méthode MCP pour les intercepteurs REQUEST et transmet toutes les demandes et réponses sans modification :

import json
import logging

# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    """
    Lambda function that handles both REQUEST and RESPONSE interceptor types.

    For REQUEST interceptors: logs the MCP method and passes request through unchanged
    For RESPONSE interceptors: passes response through unchanged
    """
    # Extract the MCP data from the event
    mcp_data = event.get('mcp', {})

    # Check if this is a REQUEST or RESPONSE interceptor based on presence of gatewayResponse
    if 'gatewayResponse' in mcp_data and mcp_data['gatewayResponse'] != None:
        # This is a RESPONSE interceptor
        logger.info("Processing RESPONSE interceptor - passing through unchanged")

        # Pass through the original request and response unchanged
        response = {
          "interceptorOutputVersion": "1.0",
          "mcp": {
              "transformedGatewayResponse": {
                  "body": mcp_data.get('gatewayResponse', {}).get('body', {}),
                  "statusCode": mcp_data.get('gatewayResponse', {}).get('statusCode', 200)
              }
          }
        }
    else:
        # This is a REQUEST interceptor
        gateway_request = mcp_data.get('gatewayRequest', {})
        request_body = gateway_request.get('body', {})
        mcp_method = request_body.get('method', 'unknown')

        # Log the MCP method
        logger.info(f"Processing REQUEST interceptor - MCP method: {mcp_method}")

        # Pass through the original request unchanged
        response = {
          "interceptorOutputVersion": "1.0",
          "mcp": {
              "transformedGatewayRequest": {
                  "body": request_body,
              }
          }
        }

    return response

Cette fonction Lambda peut être configurée en tant qu'intercepteur REQUEST et RESPONSE. Lorsqu'il est configuré en tant qu'intercepteur REQUEST, il enregistre la méthode MCP à partir de la demande entrante. Lorsqu'il est configuré en tant qu'intercepteur RESPONSE, il transmet simplement la réponse sans modification. Les deux types d'intercepteurs renvoient les données d'origine sans modification, ce qui en fait un intercepteur « direct ».

Personnalisez le routage des modèles à l'aide d'un intercepteur de requêtes

Pour les cibles d'inférence, la passerelle sélectionne une cible dans le model champ à l'aide d'un routage basé sur un modèle. Un intercepteur REQUEST peut effectuer une réécriture model avant que la passerelle n'évalue le routage, ce qui vous permet de prendre en charge un ID de modèle virtuel  : un alias stable qui ne correspond à aucun modèle configuré. L'intercepteur résout l'alias en un identifiant spécifique qualifié pour la cible dans le formulaire{targetName}/{modelId}, de sorte que les appelants n'utilisent qu'un seul nom pendant que vous contrôlez la sélection du modèle de manière centralisée.

L'intercepteur REQUEST suivant résout l'ID auto-claude du modèle virtuel en un modèle anthropique spécifique en fonction de la taille de la demande en entrée : anthropic/claude-haiku-4-5 pour les petites demandes, pour les demandes moyennes et anthropic/claude-sonnet-4-6 anthropic/claude-opus-4-7 pour les demandes volumineuses. Les appelants envoient auto-claude et la passerelle achemine chaque demande vers le modèle résolu sur la anthropic cible. Les demandes qui utilisent un autre identifiant de modèle sont transmises sans modification et suivent le routage normal basé sur le modèle.

import base64
import json
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

# The virtual model ID that this interceptor resolves to a concrete
# target-qualified ID in the form "{targetName}/{modelId}".
VIRTUAL_MODEL = "auto-claude"

# Approximate input-size thresholds (in characters) used to choose a model.
SONNET_THRESHOLD = 2000
OPUS_THRESHOLD = 8000


def resolve_auto_claude(payload):
    """Choose an Anthropic model based on the size of the request input."""
    input_size = len(json.dumps(payload.get("input", "")))
    if input_size >= OPUS_THRESHOLD:
        return "anthropic/claude-opus-4-7"
    if input_size >= SONNET_THRESHOLD:
        return "anthropic/claude-sonnet-4-6"
    return "anthropic/claude-haiku-4-5"


def lambda_handler(event, context):
    http = event.get("http", {})
    request = http.get("gatewayRequest", {})
    encoded_body = request.get("body")

    # Nothing to transform (for example, an empty body) - pass through.
    if not encoded_body:
        return {"interceptorOutputVersion": "1.0", "http": {}}

    try:
        payload = json.loads(base64.b64decode(encoded_body))
    except (ValueError, TypeError) as exc:
        logger.warning("Passing request through unchanged; could not parse body: %s", exc)
        return {"interceptorOutputVersion": "1.0", "http": {}}

    # Only resolve the virtual model ID; let everything else route normally.
    if not isinstance(payload, dict) or payload.get("model") != VIRTUAL_MODEL:
        return {"interceptorOutputVersion": "1.0", "http": {}}

    resolved = resolve_auto_claude(payload)
    logger.info("Resolved virtual model %s -> %s", VIRTUAL_MODEL, resolved)
    payload["model"] = resolved

    encoded = base64.b64encode(json.dumps(payload).encode("utf-8")).decode("utf-8")
    return {
        "interceptorOutputVersion": "1.0",
        "http": {
            "transformedGatewayRequest": {
                "body": encoded
            }
        },
    }

Associez la fonction à votre passerelle en tant qu'intercepteur REQUEST. Pour obtenir des instructions, consultez la section Configuration des intercepteurs. Le rôle de service de passerelle doit également être autorisé à invoquer la fonction. Pour plus d'informations, consultez la section Autorisations pour les intercepteurs.

Pour voir la résolution, envoyez une requête utilisant l'auto-claudealias. L'intercepteur réécrit model vers un modèle anthropique concret en fonction de la taille d'entrée, et la passerelle achemine la demande vers ce modèle sur la cible. anthropic

awscurl --service bedrock-agentcore --region us-west-2 -X POST \
    "https://GATEWAY_ID.gateway.bedrock-agentcore.us-west-2.amazonaws.com/inference/v1/responses" \
    -H "Content-Type: application/json" \
    -d '{"model": "auto-claude", "input": "Hello!", "max_output_tokens": 50}'