Começando com a avaliação em lote

Este passo a passo leva você de um agente implantado aos resultados da avaliação em lote usando um agente de suporte ao cliente da Acme Store. Você criará o agente, o implantará, gerará sessões de amostra, executará uma avaliação em lote e lerá os resultados.

Antes de começar

Verifique se você:

Para obter detalhes completos, consulte Pré-requisitos.

As constantes a seguir são usadas nos exemplos de boto3. Substitua-os por seus próprios valores depois de implantar o 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"

Etapa 1: criar e implantar o agente de amostra

Crie um AgentCore projeto e substitua o código padrão do agente pelo agente de atendimento ao cliente da Acme Store. Esse agente tem cinco ferramentas para lidar com pedidos, devoluções, remessas, descontos e escalonamentos.

Criar o projeto

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

Substitua o código do agente

Abra app/AcmeSupport/main.py e substitua seu conteúdo pelo seguinte:

"""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 e verifique

agentcore deploy

Após a implantação, verifique se o agente está em execução:

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

Você deverá ver uma resposta com os detalhes do pedido. Observe o ARN do tempo de execução, o nome do serviço e o grupo de registros de agentcore status --json — você precisará deles para os exemplos do boto3.

Etapa 2: gerar sessões de amostra

Invoque o agente com solicitações variadas para criar sessões para avaliação. Esses prompts abrangem diferentes cenários: pesquisas de pedidos, devoluções, atrasos no envio, solicitações de descontos e interações com várias ferramentas.

Aguarde de 2 a 3 minutos após a última invocação para ingerir a CloudWatch telemetria antes de continuar.

Etapa 3: Executar avaliação em lote

Inicie uma avaliação em lote para pontuar todas as sessões recentes. O serviço descobre sessões do CloudWatch Logs, compara cada avaliador em cada sessão e retorna resultados agregados.

Etapa 4: ler os detalhes por sessão

As pontuações agregadas mostram o panorama geral. Para ver as pontuações por turno e por avaliador em sessões individuais, use os comandos de visualização da CLI integrados ou leia os eventos de avaliação diretamente do Logs. CloudWatch

Próximas etapas