Cómo empezar con la evaluación de lotes

En este tutorial, se pasa de un agente desplegado a los resultados de una evaluación por lotes con un agente de atención al cliente de Acme Store. Creará el agente, lo desplegará, generará sesiones de muestra, realizará una evaluación por lotes y leerá los resultados.

Antes de empezar

Asegúrese de que:

Para obtener más información, consulte Requisitos previos.

En los ejemplos de boto3 se utilizan las siguientes constantes. Sustitúyalos por sus propios valores después de implementar el agente:

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"

Paso 1: Crear e implementar el agente de muestra

Cree un AgentCore proyecto y sustituya el código de agente predeterminado por el del agente de atención al cliente de Acme Store. Este agente tiene cinco herramientas para gestionar pedidos, devoluciones, envíos, descuentos y escaladas.

Creación del proyecto

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

Sustituya el código del agente

Abra app/AcmeSupport/main.py y sustituya su contenido por lo siguiente:

"""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()

Implemente y verifique

agentcore deploy

Tras la implementación, compruebe que el agente se esté ejecutando:

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

Debería ver una respuesta con los detalles del pedido. Anote el ARN del tiempo de ejecución, el nombre del servicio y el grupo de registros de origenagentcore status --json; los necesitará para los ejemplos de boto3.

Paso 2: Genere sesiones de muestra

Invoque al agente con diversas indicaciones para crear sesiones de evaluación. Estas indicaciones cubren diferentes escenarios: búsquedas de pedidos, devoluciones, retrasos en los envíos, solicitudes de descuento e interacciones multiherramienta.

Espere de 2 a 3 minutos después de la última invocación para asimilar la telemetría antes de continuar CloudWatch .

Paso 3: Ejecute la evaluación por lotes

Inicie una evaluación por lotes para puntuar todas las sesiones recientes. El servicio descubre las sesiones a partir de CloudWatch los registros, ejecuta cada evaluador en función de cada sesión y devuelve los resultados agregados.

Paso 4: Lea los detalles de cada sesión

Las puntuaciones agregadas muestran el panorama general. Para ver las puntuaciones por turno y por evaluador de las sesiones individuales, utilice los comandos de visualización de la CLI integrados o lea los eventos de evaluación directamente desde los registros. CloudWatch

Siguientes pasos