Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Esempi

Gli esempi seguenti mostrano le funzioni Python AWS Lambda per i casi d'uso comuni degli intercettori.

Pass-through intercettore

Questo esempio dimostra un semplice intercettore che registra il metodo MCP per gli intercettori REQUEST e trasmette tutte le richieste e le risposte senza modifiche:

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

Questa funzione Lambda può essere configurata sia come intercettore REQUEST che Response. Se configurato come intercettore REQUEST, registrerà il metodo MCP dalla richiesta in arrivo. Se configurato come intercettore di RISPOSTA, trasmetterà semplicemente la risposta invariata. Entrambi i tipi di intercettore restituiscono i dati originali senza modifiche, rendendolo un intercettore «pass-through».

Personalizza il routing del modello con un intercettore di richieste

Per i target di inferenza, il gateway seleziona un target dal campo utilizzando il routing basato su modelli. model gateway-target-inference-connector.html#gateway-target-inference-connector-routing Un intercettore REQUEST può riscrivere model prima che il gateway valuti il routing, il che consente di supportare un ID del modello virtuale: un alias stabile che non è mappato a nessun singolo modello configurato. L'interceptor risolve l'alias in un ID concreto e qualificato per la destinazione nel modulo, in modo che i chiamanti utilizzino un nome mentre tu controlli centralmente la selezione del modello. {targetName}/{modelId}

Il seguente interceptor REQUEST risolve l'ID del modello virtuale in uno specifico modello Anthropic in base auto-claude alla dimensione dell'input della richiesta: anthropic/claude-haiku-4-5 per richieste piccole, anthropic/claude-sonnet-4-6 per richieste medie e per richieste di grandi dimensioni. anthropic/claude-opus-4-7 I chiamanti inviano e auto-claude il gateway indirizza ogni richiesta al modello risolto sulla destinazione. anthropic Le richieste che utilizzano qualsiasi altro ID del modello passano invariate e seguono il normale routing basato sul modello.

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

Collega la funzione al tuo gateway come intercettore di REQUEST. Per istruzioni, consulta Configurazione degli intercettori. Il ruolo del servizio gateway deve inoltre disporre dell'autorizzazione per richiamare la funzione. Per ulteriori informazioni, vedere Autorizzazioni per gli intercettori.

Per vedere la risoluzione, invia una richiesta che utilizza l'alias. auto-claude L'intercettore riscrive un modello antropico concreto in base model alla dimensione dell'input e il gateway indirizza la richiesta a quel modello sul bersaglio. 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}'