Esegui un A/B test con il routing basato sulla destinazione

Usa lo schema di routing basato sulla destinazione quando la modifica che stai testando comporta modifiche al codice, un aggiornamento del framework o un'implementazione dell'agente completamente diversa. Target-based il routing indirizza il traffico tra più versioni dello stesso AgentCore Runtime (denominate endpoint) o tra Runtime completamente diversi. AgentCore Il AgentCore Gateway registra ogni endpoint come destinazione separata e indirizza ogni sessione verso un endpoint o l'altro in base ai pesi del traffico del test. A/B

Configurazione chiave per i test basati sul target: A/B

Questa procedura dettagliata implementa due versioni dell'agente dell'assistenza clienti, una che utilizza Claude Sonnet (controllo) e una che utilizza Claude Opus (trattamento), crea endpoint denominati per ogni versione, crea un A/B test, invia traffico, esamina i risultati e distribuisce il vincitore.

Per un confronto dettagliato dei modelli di A/B test, consulta Scelta di un modello.

Fase 1: Creare il progetto

Crea il progetto con la AgentCore CLI:

agentcore create --name ABTestTargetBased --no-agent
cd ABTestTargetBased

Fase 2: Aggiungere il runtime

Aggiungere il runtime dell'agente. Implementerai due versioni di questo runtime, una per il controllo e una per il trattamento, quindi creerai endpoint denominati per assegnare un alias a ciascuna versione.

agentcore add agent \
  --name csAgent \
  --language Python \
  --framework Strands \
  --model-provider Bedrock \
  --memory none \
  --build CodeZip

Struttura del progetto:

ABTestTargetBased/
├── agentcore/
│   ├── agentcore.json
│   ├── aws-targets.json
│   └── cdk/
└── app/
    └── csAgent/
        ├── main.py
        └── pyproject.toml

Fase 3: Implementazione delle versioni di controllo e trattamento

Sostituisci app/csAgent/main.py con la versione di controllo (usando Claude Sonnet):

"""Customer support agent — control variant."""
from strands import Agent, tool
from strands.models.bedrock import BedrockModel
from bedrock_agentcore.runtime import BedrockAgentCoreApp

app = BedrockAgentCoreApp()
MODEL_ID = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
SYSTEM_PROMPT = "You are a helpful customer support assistant for Acme Store."


@tool
def lookup_order(order_id: str) -> str:
    """Look up an order by ID."""
    orders = {
        "ORD-1001": {"status": "delivered", "item": "Blue T-Shirt", "total": "$29.99"},
        "ORD-1002": {"status": "in_transit", "item": "Running Shoes", "est_delivery": "2026-04-05"},
        "ORD-1003": {"status": "delayed", "item": "Wireless Headphones", "days_late": 5},
    }
    return str(orders.get(order_id, {"error": f"Order {order_id} not found"}))


@tool
def initiate_return(order_id: str, reason: str) -> str:
    """Initiate a return for an order."""
    return f"Return initiated for {order_id}. Reason: {reason}. Return label sent to customer email."


@tool
def apply_discount(order_id: str, discount_percent: int, reason: str) -> str:
    """Apply a discount to an order."""
    return f"Applied {discount_percent}% discount to {order_id}. Reason: {reason}."


agent = Agent(
    model=BedrockModel(model_id=MODEL_ID),
    tools=[lookup_order, initiate_return, apply_discount],
    system_prompt=SYSTEM_PROMPT,
)


@app.entrypoint
def invoke(payload, context):
    result = agent(payload.get("prompt", "Hello"))
    return {"response": result.message["content"][0]["text"]}


if __name__ == "__main__":
    app.run()

Aggiorna le dipendenzeapp/csAgent/pyproject.toml:

dependencies = [
    "aws-opentelemetry-distro",
    "bedrock-agentcore >= 1.8.0",
    "boto3",
    "botocore[crt] >= 1.35.0",
    "strands-agents[otel] >= 1.13.0",
    "opentelemetry-distro",
    "opentelemetry-instrumentation",
]

Distribuisci la versione di controllo (questo crea la versione 1):

agentcore deploy

Ora aggiorna main.py per utilizzare un modello diverso per la variante di trattamento e distribuisci (questo crea la versione 2):

MODEL_ID = "global.anthropic.claude-opus-4-6-v1"

agentcore deploy

Crea endpoint denominati per ogni versione e distribuisci:

agentcore add runtime-endpoint \
  --runtime csAgent \
  --endpoint control \
  --version 1 \
  --description "Control variant — Claude Sonnet"

agentcore add runtime-endpoint \
  --runtime csAgent \
  --endpoint treatment \
  --version 2 \
  --description "Treatment variant — Claude Opus"

agentcore deploy

Ora hai:

Verifica che il runtime funzioni:

agentcore invoke --runtime csAgent --prompt "What is the status of order ORD-1003?"

Ora hai:

Fase 4: Creare configurazioni di valutazione online

Ogni endpoint ha il proprio gruppo di log (il nome del gruppo di log termina con il nome dell'endpoint), quindi è necessaria una configurazione di valutazione online per variante:

agentcore add online-eval \
  --name controlEvalTb \
  --runtime csAgent \
  --endpoint control \
  --evaluator "Builtin.Helpfulness" \
  --sampling-rate 100.0 \
  --enable-on-create

agentcore add online-eval \
  --name treatmentEvalTb \
  --runtime csAgent \
  --endpoint treatment \
  --evaluator "Builtin.Helpfulness" \
  --sampling-rate 100.0 \
  --enable-on-create

agentcore deploy

Dopo ogni implementazione, prendi nota della configurazione di valutazione online ARN: ti serviranno entrambi durante la creazione A/B del test.

Per maggiori dettagli sulle opzioni e sulla configurazione del valutatore, consulta Creare una valutazione online.

Fase 5: Creare il gateway e gli obiettivi

Un A/B test basato su target indirizza il traffico attraverso un AgentCore gateway, pertanto il gateway e le sue due destinazioni devono essere già implementati prima di iniziare il test. Aggiungi un gateway e registra ogni endpoint di runtime come http-runtime destinazione, quindi distribuisci:

agentcore add gateway --name csGateway

agentcore add gateway-target \
  --name customer-support-control \
  --gateway csGateway \
  --type http-runtime \
  --runtime csAgent \
  --runtime-endpoint control

agentcore add gateway-target \
  --name customer-support-treatment \
  --gateway csGateway \
  --type http-runtime \
  --runtime csAgent \
  --runtime-endpoint treatment

agentcore deploy

Fase 6: Creare il test A/B

Inizia il A/B test conagentcore run ab-test. Ogni variante fa riferimento a uno degli obiettivi del gateway che hai creato e dispone di una propria configurazione di valutazione online. Il comando avvia il test direttamente sul servizio rispetto al gateway già distribuito.

Passaggio 7: invio del traffico attraverso il Gateway AgentCore

Dopo l'esecuzione del A/B test, invia il traffico tramite l'endpoint HTTP AgentCore Gateway. Il AgentCore Gateway assegna ogni richiesta a una variante (controllo o trattamento) in base all'ID della sessione di runtime.

Come funziona l'assegnazione delle varianti

Il AgentCore Gateway utilizza l'X-Amzn-Bedrock-AgentCore-Runtime-Session-Idintestazione per determinare a quale destinazione indirizzare il traffico. Questa intestazione è facoltativa: se non la fornite, il runtime genera automaticamente un ID di sessione. Il AgentCore Gateway utilizza quindi l'ID di sessione (indipendentemente dal fatto che sia stato fornito dall'utente o generato dal runtime) per assegnare la richiesta a una variante in base ai pesi di traffico configurati.

L'assegnazione della sessione è permanente: una volta assegnato un ID di sessione a una variante, tutte le richieste successive con lo stesso ID di sessione vengono indirizzate allo stesso obiettivo. Ciò garantisce un'esperienza coerente all'interno di una sessione, pur continuando a distribuire nuove sessioni tra le varianti in base alla suddivisione del traffico.

Genera traffico per i test

Salva lo script seguente comeloadgen.sh, sostituendo <gateway-id> e <target-name> con i valori dell'output di distribuzione. Puoi anche copiare l'URL di invocazione completo da: agentcore view ab-test <ab-test-id>

#!/bin/bash
export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id)
export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key)
export AWS_SESSION_TOKEN=$(aws configure get aws_session_token)

GATEWAY_URL="https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/<target-name>/invocations"

PROMPTS=(
  "What is the status of order ORD-1003?"
  "I want to return order ORD-1001, it doesn't fit."
  "My order ORD-1003 is late. Can I get a discount?"
  "Where is my order ORD-1002?"
  "I need help with a return for order ORD-1001. The color is wrong."
  "Can you check on order ORD-1003? I've been waiting forever."
  "I'd like to cancel order ORD-1002 if it hasn't shipped yet."
  "Order ORD-1003 is delayed again. This is unacceptable."
  "What's your return policy for order ORD-1001?"
  "My headphones order ORD-1003 still hasn't arrived. What can you do?"
)

for i in $(seq 1 30); do
  PROMPT="${PROMPTS[$(( (i - 1) % ${#PROMPTS[@]} ))]}"
  echo "=== Request $i: $PROMPT ==="
  curl -s --aws-sigv4 "aws:amz:us-west-2:bedrock-agentcore" \
    --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
    -H "x-amz-security-token: $AWS_SESSION_TOKEN" \
    -H "Content-Type: application/json" \
    -H "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id: $(uuidgen)" \
    -d "{\"prompt\": \"$PROMPT\"}" \
    -X POST \
    "$GATEWAY_URL"
  echo ""
  sleep 2
done

Esegui lo script :

bash loadgen.sh

Fase 8: Ottenere risultati

Esegui un sondaggio sul A/B test per monitorare i risultati man mano che le dimensioni del campione aumentano. I sondaggi non influiscono sulla validità statistica.

Interpretazione dei risultati

Fase 9: Conferma i risultati e interrompi il test A/B

Una volta che il A/B test raggiunge la significatività statistica, rivedi i risultati e interrompi l'esperimento.

Passaggio 10: schiera il vincitore

Dopo aver interrotto il A/B test, indirizza tutto il traffico verso la variante vincente.

agentcore promote ab-test -i <ab-test-id>
agentcore deploy

promoteinterrompe il A/B test (se è ancora in esecuzione), aggiorna l'endpoint di controllo in modo che punti alla versione del trattamento (ad esempio, eseguendo l'aggiornamento control dalla versione 1 alla versione 2) e rimuove l'endpoint del trattamento. Esegui agentcore deploy per applicare le modifiche.

In alternativa, puoi schierare manualmente il vincitore effettuando una delle seguenti operazioni:

Fasi successive

Dopo aver schierato il vincitore:

Comprendere i risultati

Quando si chiamaGetABTest, la risposta include un results oggetto una volta che la pipeline di aggregazione ha elaborato un numero sufficiente di sessioni. I risultati contengono metriche per valutatore suddivise per variante.

Struttura dei risultati

{
  "results": {
    "analysisTimestamp": "2026-04-30T18:45:00Z",
    "evaluatorMetrics": [
      {
        "evaluatorArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:evaluator/Builtin.Helpfulness",
        "controlStats": {
          "variantName": "C",
          "sampleSize": 24,
          "mean": 0.72
        },
        "variantResults": [
          {
            "variantName": "T1",
            "sampleSize": 6,
            "mean": 0.85,
            "absoluteChange": 0.13,
            "percentChange": 18.1,
            "pValue": 0.032,
            "confidenceInterval": {
              "lower": 0.02,
              "upper": 0.24
            },
            "isSignificant": true
          }
        ]
      }
    ]
  }
}

Riferimento ai campi

Risoluzione dei problemi

A/B il test non mostra risultati dopo l'invio del traffico

I risultati non vengono visualizzati immediatamente. Il tempo necessario dipende dal timeout della sessione configurato nella configurazione di valutazione online: una sessione viene considerata completa solo dopo che non arrivano nuove richieste entro la finestra di timeout. Al termine di una sessione, aspettatevi risultati entro circa 15 minuti.

Se i risultati non vengono ancora visualizzati dopo questa finestra: