Commencer à évaluer les lots

Cette procédure pas à pas vous permet de passer d'un agent déployé à des résultats d'évaluation par lots à l'aide d'un agent du support client d'Acme Store. Vous allez créer l'agent, le déployer, générer des exemples de sessions, exécuter une évaluation par lots et lire les résultats.

Avant de commencer

Assurez-vous d’avoir :

Pour plus de détails, consultez la section Conditions préalables.

Les constantes suivantes sont utilisées dans les exemples boto3. Remplacez-les par vos propres valeurs après avoir déployé l'agent :

REGION       = "us-west-2"
AGENT_ARN    = "arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/AcmeSupport-abc123"
SERVICE_NAME = "AcmeSupport-abc123.DEFAULT"
LOG_GROUP    = "/aws/bedrock-agentcore/runtimes/AcmeSupport-abc123-DEFAULT"

Étape 1 : créer et déployer l'exemple d'agent

Créez un AgentCore projet et remplacez le code d'agent par défaut par celui de l'agent de support client Acme Store. Cet agent dispose de cinq outils pour gérer les commandes, les retours, l'expédition, les remises et les escalades.

Création du projet

agentcore create --name AcmeSupport --framework Strands --model-provider Bedrock --memory none
cd AcmeSupport

Remplacez le code de l'agent

Ouvrez app/AcmeSupport/main.py et remplacez son contenu par ce qui suit :

"""Acme Store customer support agent."""
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-6"
SYSTEM_PROMPT = (
    "You are a helpful customer support assistant for Acme Store. "
    "Help customers with their orders, returns, and shipping questions."
)


@tool
def lookup_order(order_id: str) -> str:
    """Look up an order by ID and return its status, item, and delivery details."""
    orders = {
        "ORD-1001": {
            "status": "delivered",
            "item": "Blue T-Shirt (L)",
            "delivered": "2026-03-28",
            "total": "$29.99",
        },
        "ORD-1002": {
            "status": "in_transit",
            "item": "Running Shoes (10)",
            "shipped": "2026-03-30",
            "est_delivery": "2026-04-05",
            "total": "$89.99",
        },
        "ORD-1003": {
            "status": "delayed",
            "item": "Wireless Headphones",
            "shipped": "2026-03-25",
            "est_delivery": "2026-03-29",
            "days_late": 5,
            "total": "$59.99",
        },
        "ORD-1004": {
            "status": "processing",
            "item": "Yoga Mat",
            "ordered": "2026-04-02",
            "total": "$34.99",
        },
        "ORD-1005": {
            "status": "delivered",
            "item": "Coffee Maker",
            "delivered": "2026-03-20",
            "total": "$149.99",
        },
    }
    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. Sends a return label to the customer."""
    return (
        f"Return initiated for {order_id}. Reason: {reason}. "
        "Return label sent to customer email. Please ship within 14 days."
    )


@tool
def check_shipping_status(order_id: str) -> str:
    """Check detailed shipping status including carrier location and delays."""
    statuses = {
        "ORD-1002": (
            "Package is with carrier, currently in Portland OR. "
            "On schedule for April 5."
        ),
        "ORD-1003": (
            "Package delayed at distribution center in Memphis TN. "
            "Original delivery was March 29. Now 5 days late. "
            "Acme Store policy: orders delayed 3+ days qualify for 15% discount."
        ),
    }
    return statuses.get(order_id, f"No active shipment found for {order_id}.")


@tool
def apply_discount(order_id: str, discount_percent: int, reason: str) -> str:
    """Apply a percentage discount to an order and issue a refund."""
    return (
        f"Applied {discount_percent}% discount to {order_id}. "
        f"Reason: {reason}. Refund will appear in 3-5 business days."
    )


@tool
def escalate_to_human(reason: str) -> str:
    """Escalate the conversation to a human support agent."""
    return (
        f"Escalated to human agent. Reason: {reason}. "
        "Estimated wait time: 3 minutes."
    )


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


@app.entrypoint
def invoke(payload, context):
    result = agent(payload.get("prompt", "Hello"))
    return {"response": str(result)}


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

Déployer et vérifier

agentcore deploy

Après le déploiement, vérifiez que l'agent est en cours d'exécution :

agentcore invoke --prompt "What's the status of order ORD-1001?"

Vous devriez voir une réponse avec les détails de la commande. Notez l'ARN d'exécution, le nom du service et le groupe de journaux provenant de agentcore status --json : vous en aurez besoin pour les exemples de boto3.

Étape 2 : générer des exemples de sessions

Invoquez l'agent à l'aide de diverses instructions pour créer des sessions d'évaluation. Ces instructions couvrent différents scénarios : recherches de commandes, retours, délais d'expédition, demandes de remises et interactions avec plusieurs outils.

Attendez 2 à 3 minutes après le dernier appel pour CloudWatch assimiler la télémétrie avant de continuer.

Étape 3 : Exécuter l'évaluation par lots

Lancez une évaluation par lots pour évaluer toutes les sessions récentes. Le service découvre les sessions à partir CloudWatch des journaux, exécute chaque évaluateur par rapport à chaque session et renvoie des résultats agrégés.

Étape 4 : lire les détails de chaque session

Les scores agrégés vous donnent une vue d'ensemble. Pour consulter les scores par tour et par évaluateur pour chaque session, utilisez les commandes de visualisation intégrées de la CLI ou lisez les événements d'évaluation directement à partir des journaux. CloudWatch

Étapes suivantes