Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ejemplos

Los siguientes ejemplos muestran las funciones AWS Lambda de Python para casos de uso comunes de interceptores.

Pass-through interceptor

Este ejemplo muestra un interceptor simple que registra el método MCP para los interceptores REQUEST y pasa todas las solicitudes y respuestas sin cambios:

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

Esta función de Lambda se puede configurar como interceptor de SOLICITUD y de RESPUESTA. Cuando se configura como un interceptor REQUEST, registrará el método MCP de la solicitud entrante. Cuando se configura como un interceptor RESPONSE, simplemente transmitirá la respuesta sin cambios. Ambos tipos de interceptores devuelven los datos originales sin modificarlos, lo que lo convierte en un interceptor de «transferencia».

Personalice el modelo de enrutamiento con un interceptor de solicitudes

Para los objetivos de inferencia, la puerta de enlace selecciona un objetivo del model campo mediante un enrutamiento basado en modelos. Un interceptor REQUEST puede reescribirse model antes de que la puerta de enlace evalúe el enrutamiento, lo que permite utilizar un ID de modelo virtual: un alias estable que no se asigna a ningún modelo configurado. El interceptor convierte el alias en un identificador concreto que cumple con los requisitos del objetivo en el formulario{targetName}/{modelId}, de modo que las personas que llaman usan un nombre mientras tú controlas la selección del modelo de forma centralizada.

El siguiente interceptor de solicitudes convierte el ID auto-claude del modelo virtual en un modelo antrópico específico en función del tamaño de la entrada de la solicitud: anthropic/claude-haiku-4-5 anthropic/claude-sonnet-4-6 para solicitudes pequeñas, medianas y grandesanthropic/claude-opus-4-7. Las personas que llaman envían auto-claude y la puerta de enlace redirige cada solicitud al modelo resuelto del destino. anthropic Las solicitudes que utilizan cualquier otro identificador de modelo se tramitan sin cambios y siguen el enrutamiento normal basado en el modelo.

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
            }
        },
    }

Adjunte la función a su puerta de enlace como un interceptor REQUEST. Para obtener instrucciones, consulte Configuración de interceptores. El rol de servicio de puerta de enlace también debe tener permiso para invocar la función. Para obtener más información, consulte Permisos para interceptores.

Para ver la resolución, envíe una solicitud que utilice el auto-claude alias. El interceptor reescribe model en un modelo antrópico concreto en función del tamaño de la entrada, y la puerta de enlace dirige la solicitud a ese modelo en el objetivo. 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}'