Exécuter un A/B test avec un routage basé sur les cibles

Utilisez le modèle de routage basé sur la cible lorsque la modification que vous testez implique des modifications de code, une mise à niveau du framework ou une implémentation d'agent totalement différente. Target-based le routage achemine le trafic entre plusieurs versions du même AgentCore environnement d'exécution (points de terminaison nommés) ou entre des environnements d' AgentCore exécution totalement différents. La AgentCore passerelle enregistre chaque point de terminaison en tant que cible distincte et achemine chaque session vers l'un ou l'autre point de terminaison en fonction des pondérations du trafic du A/B test.

Configuration clé pour les tests basés sur des cibles A/B  :

Cette procédure pas à pas déploie deux versions de l'agent de support client, l'une utilisant Claude Sonnet (contrôle) et l'autre utilisant Claude Opus (traitement). Elle crée des points de terminaison nommés pour chaque version, crée un A/B test, envoie du trafic, examine les résultats et désigne le gagnant.

Pour une comparaison détaillée des modèles de A/B test, voir Choisir un modèle.

Étape 1 : Création du projet

Créez le projet à l'aide de la AgentCore CLI :

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

Étape 2 : ajouter le runtime

Ajoutez le runtime de l'agent. Vous déploierez deux versions de ce runtime, l'une pour le contrôle et l'autre pour le traitement, puis créerez des points de terminaison nommés pour aliaser chaque version.

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

Structure du projet :

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

Étape 3 : Déployer les versions de contrôle et de traitement

Remplacez app/csAgent/main.py par la version de contrôle (en utilisant 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()

Mettre à jour app/csAgent/pyproject.toml les dépendances :

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",
]

Déployez la version de contrôle (cela crée la version 1) :

agentcore deploy

Effectuez maintenant main.py la mise à jour pour utiliser un modèle différent pour la variante de traitement et déployez (cela crée la version 2) :

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

agentcore deploy

Créez des points de terminaison nommés pour chaque version et déployez :

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

Vous disposez désormais de :

Vérifiez que le moteur d'exécution fonctionne :

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

Vous disposez désormais de :

Étape 4 : Création de configurations d'évaluation en ligne

Chaque point de terminaison possède son propre groupe de journaux (le nom du groupe de journaux se termine par le nom du point de terminaison). Vous avez donc besoin d'une configuration d'évaluation en ligne par 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

Après chaque déploiement, notez l'ARN de configuration d'évaluation en ligne : vous aurez besoin des deux lors de la création du A/B test.

Pour plus de détails sur les options et la configuration de l'évaluateur, voir Créer une évaluation en ligne.

Étape 5 : Création de la passerelle et des cibles

Un A/B test basé sur des cibles achemine le trafic via une AgentCore passerelle, de sorte que la passerelle et ses deux cibles doivent déjà être déployées avant que vous ne commenciez le test. Ajoutez une passerelle et enregistrez chaque point de terminaison d'exécution en tant que http-runtime cible, puis déployez :

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

Étape 6 : Création du A/B test

Commencez le A/B test avecagentcore run ab-test. Chaque variante fait référence à l'une des cibles de passerelle que vous avez créées et possède sa propre configuration d'évaluation en ligne. La commande lance le test directement sur le service par rapport à la passerelle déjà déployée.

Étape 7 : envoyer du trafic via la AgentCore passerelle

Une fois le A/B test exécuté, envoyez le trafic via le point de terminaison HTTP AgentCore Gateway. La AgentCore passerelle attribue chaque demande à une variante (contrôle ou traitement) en fonction de l'ID de session d'exécution.

Comment fonctionne l'attribution de variantes

La AgentCore passerelle utilise l'X-Amzn-Bedrock-AgentCore-Runtime-Session-Iden-tête pour déterminer la cible vers laquelle acheminer le trafic. Cet en-tête est facultatif. Si vous ne le fournissez pas, le moteur d'exécution génère automatiquement un identifiant de session. La AgentCore passerelle utilise ensuite l'ID de session (que vous l'ayez fourni ou que le moteur d'exécution l'ait généré) pour attribuer la demande à une variante en fonction de vos pondérations de trafic configurées.

L'attribution de session est permanente : une fois qu'un identifiant de session est attribué à une variante, toutes les demandes suivantes portant le même identifiant de session sont acheminées vers la même cible. Cela garantit une expérience cohérente au sein d'une session tout en répartissant les nouvelles sessions entre les variantes en fonction de la répartition du trafic.

Générer du trafic pour les tests

Enregistrez le script suivant sous le loadgen.sh nom, en <target-name> remplaçant <gateway-id> et par les valeurs de votre sortie de déploiement. Vous pouvez également copier l'URL d'appel complète depuis 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

Exécutez le script  :

bash loadgen.sh

Étape 8 : Obtenir des résultats

Interrogez le A/B test pour surveiller les résultats à mesure que la taille des échantillons augmente. Le sondage n'affecte pas la validité des statistiques.

Interprétation des résultats

Étape 9 : Confirmer les résultats et arrêter le A/B test

Une fois que le A/B test atteint une signification statistique, passez en revue les résultats et arrêtez l'expérience.

Étape 10 : Déployer le gagnant

Après avoir arrêté le A/B test, acheminez tout le trafic vers la variante gagnante.

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

promotearrête le A/B test (s'il est toujours en cours d'exécution), met à jour le point final de contrôle pour qu'il pointe vers la version du traitement (par exemple, mise à jour control de la version 1 vers la version 2) et supprime le point de terminaison du traitement. Exécutez agentcore deploy pour appliquer les modifications.

Vous pouvez également déployer manuellement le gagnant en effectuant l'une des opérations suivantes :

Étapes suivantes

Après avoir déployé le gagnant :

Comprendre les résultats

Lorsque vous appelezGetABTest, la réponse inclut un results objet une fois que le pipeline d'agrégation a traité suffisamment de sessions. Les résultats contiennent des métriques par évaluateur ventilées par variante.

Structure des résultats

{
  "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
          }
        ]
      }
    ]
  }
}

Référence de champ

Résolution des problèmes

A/B le test ne montre aucun résultat après l'envoi de trafic

Les résultats n'apparaissent pas immédiatement. Le temps nécessaire dépend du délai d'expiration de session configuré dans votre configuration d'évaluation en ligne. Une session est considérée comme terminée uniquement lorsqu'aucune nouvelle demande n'est arrivée dans le délai imparti. Après la fin d'une séance, attendez-vous à des résultats dans un délai d'environ 15 minutes.

Si les résultats ne s'affichent toujours pas après cette fenêtre :