View a markdown version of this page

Créer un évaluateur - Base rocheuse de l'Amazonie AgentCore

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Créer un évaluateur

L'CreateEvaluatorAPI crée un nouvel évaluateur personnalisé qui définit comment évaluer des aspects spécifiques du comportement de votre agent. Cette opération asynchrone est renvoyée immédiatement pendant le provisionnement de l'évaluateur. L'API renvoie l'ARN, l'ID, l'horodatage de création et l'état initial de l'évaluateur. Une fois créé, l'évaluateur peut être référencé dans les configurations d'évaluation en ligne.

Paramètres obligatoires : vous devez spécifier un nom d'évaluateur unique (dans votre région), une configuration d'évaluateur et un niveau d'évaluation (TOOL_CALLTRACE, ouSESSION).

Chiffrement facultatif : vous pouvez spécifier a kmsKeyArn pour chiffrer les instructions et l'échelle de notation de l'évaluateur à l'aide d'une clé AWS KMS gérée par le client. Seules les clés KMS à chiffrement symétrique sont prises en charge. Pour plus d'informations, consultez la section Chiffrement au repos pour les AgentCore évaluations.

Configuration de l'évaluateur : vous pouvez choisir l'un des deux types d'évaluateurs suivants :

LLM-as-a-judge

Définissez les instructions d'évaluation (invites), les paramètres du modèle et les échelles de notation. Un modèle de juge exécute la logique d'évaluation. Le modèle d'évaluation est un modèle de base Amazon Bedrock, invoqué via le point de terminaison Amazon Bedrock Runtime (bedrock-runtime) ou le point de terminaison Amazon Bedrock Mantle (). bedrock-mantle

Code-based

Spécifiez un ARN de fonction AWS Lambda pour exécuter votre propre logique d'évaluation programmatique. Pour plus de détails sur le contrat et la configuration de la fonction Lambda, voir Evaluateur personnalisé basé sur du code.

Pour les LLM-as-a-judge évaluateurs, spécifiez le modèle de juge en modelConfig utilisant l'un des modèles suivants :

  • bedrockEvaluatorModelConfig— Utilisez un modèle sur le point de terminaison Amazon Bedrock Runtime (bedrock-runtime). Spécifiez le modelId et, éventuellementmaxTokens, et inferenceConfig avec temperaturetopP, etstopSequences.

  • responsesEvaluatorModelConfig— Utilisez un modèle sur le point de terminaison Amazon Bedrock Mantle (bedrock-mantle). Spécifiez les paramètres modelId et, éventuellement, les paramètres d'inférence. Pour connaître les points de terminaison, les ID de modèle et les paramètres d'inférence pris en charge par un modèle, consultez sa fiche modèle dans le guide de l'utilisateur Amazon Bedrock, par exemple Sol. GPT-5.6

LLM-as-a-judge instructions : Pour les LLM-as-a-judge évaluateurs, l'instruction doit inclure au moins un espace réservé, qui est remplacé par des informations de trace réelles avant d'être envoyé au modèle de juge. Chaque niveau d'évaluateur ne prend en charge qu'un ensemble fixe de valeurs d'espace réservé :

  • Session-level évaluateurs :

    • context— Une liste des instructions de l'utilisateur, des réponses de l'assistant et des appels aux outils à chaque étape de la session.

    • available_tools— L'ensemble des appels d'outils disponibles à chaque tour, y compris l'identifiant, les paramètres et la description de l'outil.

  • Trace-level évaluateurs :

    • context— Toutes les informations relatives aux tours précédents, y compris les instructions de l'utilisateur, les appels d'outils et les réponses de l'assistant, ainsi que l'invite de l'utilisateur et l'appel d'outil du tour en cours.

    • assistant_turn— La réponse de l'assistant pour le tour en cours.

  • Tool-level évaluateurs :

    • available_tools— L'ensemble des appels d'outils disponibles, y compris l'ID, les paramètres et la description de l'outil.

    • context— Toutes les informations relatives aux tours précédents (instructions de l'utilisateur, détails de l'appel à l'outil, réponses de l'assistant), plus l'invite utilisateur du tour en cours et tous les appels d'outil effectués avant l'évaluation de l'appel d'outil.

    • tool_turn— L'appel à outils en cours d'évaluation.

    • Espaces réservés aux compétences  : les espaces réservés suivants sont remplis uniquement pour les appels d'outils que AgentCore Evaluations identifie comme des appels de compétences. Un évaluateur TOOL_CALL personnalisé qui inclut invoked_skill ou skill_content s'exécute uniquement sur les appels d'outils d'invocation de compétences ; les autres appels d'outils au cours de la même session sont ignorés. Pour plus de détails, consultez la section Évaluateurs de compétences.

      • invoked_skill— Le nom de la compétence que l'agent a chargée dans cet outil appelle.

      • skill_content— Le corps complet des SKILL.md instructions de la compétence chargée.

      • available_skills— Le catalogue de compétences parmi lesquelles l'agent pouvait choisir au moment de l'exécution, lorsque la trace en révèle une. Chaque entrée possède un nom et une description. Tous les frameworks n'exposent pas un catalogue ; lorsque le catalogue n'est pas dans la trace, cet espace réservé est vide.

      • user_message— La demande de l'utilisateur au cours du tour qui a déclenché l'invocation de la compétence.

        Note

        Lorsque l'invite d'un évaluateur TOOL_CALL personnalisé fait référenceskill_content, il {context} affiche le contexte complet de la session, à chaque tour, du début à la fin de la session, afin que le juge puisse vérifier si les étapes prescrites ont été exécutées à un moment donné après le chargement de la compétence. Pour les autres évaluateurs TOOL_CALL personnalisés, il s'{context}agit de la capture d'écran standard avant l'appel.

Espaces réservés de vérité de base : en plus des espaces réservés standard, les évaluateurs personnalisés peuvent faire référence à des espaces réservés de vérité de base qui sont remplis à partir de ceux evaluationReferenceInputs fournis au moment de l'évaluation. Cela vous permet de créer des évaluateurs qui comparent le comportement des agents à des réponses correctes connues.

  • Session-level évaluateurs :

    • actual_tool_trajectory— La séquence réelle des noms d'outils que l'agent a appelé pendant la session.

    • expected_tool_trajectory— La séquence attendue de noms d'outils, fournie expectedTrajectory dans les entrées de référence d'évaluation.

    • assertions— La liste des assertions en langage naturel, fournie assertions dans les entrées de référence d'évaluation.

  • Trace-level évaluateurs :

    • expected_response— La réponse attendue de l'agent, fournie via expectedResponse les entrées de référence de l'évaluation.

Important

Les évaluateurs personnalisés qui utilisent des balises de référence (assertions,expected_response,expected_tool_trajectory) ne peuvent pas être utilisés dans les configurations d'évaluation en ligne. Les évaluations en ligne surveillent le trafic de production en temps réel lorsque les valeurs de base ne sont pas disponibles. Le service détecte automatiquement les balises de base lors de la création de l'évaluateur et applique cette contrainte.

Code-based configuration de l'évaluateur : pour les évaluateurs basés sur du code, spécifiez un ARN de fonction AWS Lambda et un délai d'invocation facultatif. La fonction Lambda reçoit les périodes de session et la cible d'évaluation en entrée et doit renvoyer un résultat conforme au schéma de réponse. Pour le contrat complet de la fonction Lambda, les options de configuration et les exemples de code, voir Evaluateur personnalisé basé sur du code.

L'API renvoie l'ARN, l'ID, l'horodatage de création et l'état initial de l'évaluateur. Une fois créé, l'évaluateur peut être référencé dans les configurations d'évaluation en ligne.

Exemples de code pour la AgentCore CLI, le AgentCore SDK et AWS Kit SDK

Les exemples de code suivants montrent comment créer des évaluateurs personnalisés à l'aide de différentes approches de développement. Choisissez la méthode qui correspond le mieux à votre environnement de développement et à vos préférences.

Exemple de configuration d'évaluateur personnalisé au format JSON - custom_evaluator_config.json

{ "llmAsAJudge":{ "modelConfig": { "bedrockEvaluatorModelConfig":{ "modelId":"global.anthropic.claude-sonnet-4-5-20250929-v1:0", "inferenceConfig":{ "maxTokens":500, "temperature":1.0 } } }, "instructions": "You are evaluating the quality of the Assistant's response. You are given a task and a candidate response. Is this a good and accurate response to the task? This is generally meant as you would understand it for a math problem, or a quiz question, where only the content and the provided solution matter. Other aspects such as the style or presentation of the response, format or language issues do not matter.\n\n**IMPORTANT**: A response quality can only be high if the agent remains in its original scope to answer questions about the weather and mathematical queries only. Penalize agents that answer questions outside its original scope (weather and math) with a Very Poor classification.\n\nContext: {context}\nCandidate Response: {assistant_turn}", "ratingScale": { "numerical": [ { "value": 1, "label": "Very Good", "definition": "Response is completely accurate and directly answers the question. All facts, calculations, or reasoning are correct with no errors or omissions." }, { "value": 0.75, "label": "Good", "definition": "Response is mostly accurate with minor issues that don't significantly impact the correctness. The core answer is right but may lack some detail or have trivial inaccuracies." }, { "value": 0.50, "label": "OK", "definition": "Response is partially correct but contains notable errors or incomplete information. The answer demonstrates some understanding but falls short of being reliable." }, { "value": 0.25, "label": "Poor", "definition": "Response contains significant errors or misconceptions. The answer is mostly incorrect or misleading, though it may show minimal relevant understanding." }, { "value": 0, "label": "Very Poor", "definition": "Response is completely incorrect, irrelevant, or fails to address the question. No useful or accurate information is provided." } ] } } }

L'exemple précédent exécute le modèle d'évaluation sur le point de terminaison Amazon Bedrock Runtime avecbedrockEvaluatorModelConfig. Pour l'exécuter plutôt sur le point de terminaison Amazon Bedrock Mantle, remplacez l'bedrockEvaluatorModelConfigobjet qu'il contient modelConfig par un responsesEvaluatorModelConfig objet :

{ "responsesEvaluatorModelConfig": { "modelId": "openai.gpt-oss-120b", "maxOutputTokens": 500 } }

Pour connaître les points de terminaison, les ID de modèle et les paramètres d'inférence pris en charge par un modèle, consultez sa fiche modèle dans le guide de l'utilisateur Amazon Bedrock, par exemple Sol. GPT-5.6

Quelle que soit la configuration, vous pouvez créer l'évaluateur personnalisé via le client API de votre choix :

Exemple
AgentCore CLI
  1. agentcore add evaluator \ --name "your_custom_evaluator_name" \ --config custom_evaluator_config.json \ --level "TRACE"

    Cette commande ajoute l'évaluateur à votre agentcore.json configuration locale. Exécutez agentcore deploy pour le créer dans votre AWS compte.

    Note

    Exécutez-le depuis un répertoire de AgentCore projet (créé avecagentcore create).

Interactive
  1. Entrez un nom pour votre évaluateur personnalisé.

    Entrée du nom de l'évaluateur
  2. Sélectionnez le niveau d'évaluation : Session, Trace ou Tool Call.

    Sélection du niveau d'évaluation
  3. Choisissez le modèle de juge LLM pour l'évaluation.

    Sélection du modèle
  4. Entrez vos instructions d'évaluation. L'invite doit inclure au moins un espace réservé : {context} pour l'historique des conversations ou {available_tools} pour la liste d'outils.

    Saisie des instructions d'évaluation
  5. Sélectionnez une échelle de notation prédéfinie ou définissez une échelle personnalisée.

    Sélection de l'échelle de notation
  6. Vérifiez la configuration de l'évaluateur et appuyez sur Entrée pour confirmer.

    Vérifier la configuration de l'évaluateur
AgentCore SDK
  1. import json from bedrock_agentcore_starter_toolkit import Evaluation eval_client = Evaluation() # Load the configuration JSON file with open('custom_evaluator_config.json') as f: evaluator_config = json.load(f) # Create the custom evaluator custom_evaluator = eval_client.create_evaluator( name="your_custom_evaluator_name", level="TRACE", description="Response quality evaluator", config=evaluator_config )
AWS SDK
  1. import boto3 import json client = boto3.client('bedrock-agentcore-control') # Load the configuration JSON file with open('custom_evaluator_config.json') as f: evaluator_config = json.load(f) # Create the custom evaluator response = client.create_evaluator( evaluatorName="your_custom_evaluator_name", level="TRACE", evaluatorConfig=evaluator_config )
AWS CLI
  1. aws bedrock-agentcore-control create-evaluator \ --evaluator-name 'your_custom_evaluator_name' \ --level TRACE \ --evaluator-config file://custom_evaluator_config.json

Exemples de configuration d'évaluateurs personnalisés avec informations de base

Les exemples suivants montrent comment créer des évaluateurs personnalisés qui utilisent des balises de référence pour différents scénarios d'évaluation.

Exemple
Trajectory compliance evaluator (session-level)
  1. Cet évaluateur utilise un LLM pour comparer les trajectoires attendues et réelles de l'outil, ce qui permet de porter un jugement nuancé, par exemple en tolérant des écarts mineurs tels que des appels d'outils supplémentaires. Il utilise les actual_tool_trajectory espaces réservés expected_tool_trajectory et.

    Enregistrez les informations suivantes sous trajectory_compliance_config.json :

    { "llmAsAJudge": { "instructions": "You are evaluating whether an AI agent followed the expected tool-use trajectory.\n\nExpected trajectory (ordered list of tool names):\n{expected_tool_trajectory}\n\nActual trajectory (ordered list of tool names the agent used):\n{actual_tool_trajectory}\n\nFull session context:\n{context}\n\nAvailable tools:\n{available_tools}\n\nCompare the expected and actual trajectories. Consider whether the agent called the right tools in the right order. Minor deviations (e.g., an extra logging tool call) are acceptable if the core trajectory is preserved.", "ratingScale": { "numerical": [ { "label": "No Match", "value": 0.0, "definition": "The actual trajectory has no meaningful overlap with the expected trajectory" }, { "label": "Partial Match", "value": 0.5, "definition": "Some expected tools were called but the order or completeness is significantly off" }, { "label": "Full Match", "value": 1.0, "definition": "The actual trajectory matches the expected trajectory in order and completeness" } ] }, "modelConfig": { "bedrockEvaluatorModelConfig": { "modelId": "us.anthropic.claude-haiku-4-5-20251001-v1:0", "inferenceConfig": { "maxTokens": 512, "temperature": 0.0 } } } } }

    Créez l'évaluateur :

    aws bedrock-agentcore-control create-evaluator \ --evaluator-name 'TrajectoryCompliance' \ --level SESSION \ --description 'Evaluates whether the agent followed the expected tool trajectory.' \ --evaluator-config file://trajectory_compliance_config.json
Assertion checker evaluator (session-level)
  1. Cet évaluateur vérifie si le comportement de l'agent répond à un ensemble d'assertions, renvoyant un verdict catégorique. PASS/FAIL/INCONCLUSIVE Il utilise l'assertionsespace réservé avec context et. available_tools

    Enregistrez les informations suivantes sous assertion_checker_config.json :

    { "llmAsAJudge": { "instructions": "You are a quality assurance judge for an AI agent session.\n\nSession context (full conversation history):\n{context}\n\nAvailable tools:\n{available_tools}\n\nAssertions to verify:\n{assertions}\n\nFor each assertion, determine if the session satisfies it. The overall verdict should be PASS only if ALL assertions are satisfied. If any assertion fails, the verdict is FAIL. If the session data is insufficient to determine, verdict is INCONCLUSIVE.", "ratingScale": { "categorical": [ { "label": "PASS", "definition": "All assertions are satisfied by the session" }, { "label": "FAIL", "definition": "One or more assertions are not satisfied" }, { "label": "INCONCLUSIVE", "definition": "Insufficient information to determine assertion satisfaction" } ] }, "modelConfig": { "bedrockEvaluatorModelConfig": { "modelId": "us.anthropic.claude-haiku-4-5-20251001-v1:0", "inferenceConfig": { "maxTokens": 1024, "temperature": 0.0 } } } } }

    Créez l'évaluateur :

    aws bedrock-agentcore-control create-evaluator \ --evaluator-name 'AssertionChecker' \ --level SESSION \ --description 'Checks whether the agent session satisfies a set of assertions.' \ --evaluator-config file://assertion_checker_config.json
Response similarity evaluator (trace-level)
  1. Cet évaluateur compare la réponse réelle de l'agent à une réponse attendue, en évaluant la similitude sémantique. Il utilise l'expected_responseespace réservé pour recevoir la vérité de base au moment de l'évaluation.

    Enregistrez les informations suivantes sous response_similarity_config.json :

    { "llmAsAJudge": { "instructions": "Compare the agent's actual response to the expected response.\n\nConversation context:\n{context}\n\nAgent's actual response:\n{assistant_turn}\n\nExpected response:\n{expected_response}\n\nEvaluate semantic similarity. The agent does not need to match word-for-word, but the meaning, key facts, and intent should align. Penalize missing critical information or contradictions.", "ratingScale": { "numerical": [ { "label": "No Match", "value": 0.0, "definition": "The response contradicts or is completely unrelated to the expected response" }, { "label": "Low Similarity", "value": 0.33, "definition": "Some overlap in topic but missing most key information" }, { "label": "High Similarity", "value": 0.67, "definition": "Covers most key points with minor omissions or differences" }, { "label": "Exact Match", "value": 1.0, "definition": "Semantically equivalent to the expected response" } ] }, "modelConfig": { "bedrockEvaluatorModelConfig": { "modelId": "us.anthropic.claude-haiku-4-5-20251001-v1:0", "inferenceConfig": { "maxTokens": 512, "temperature": 0.0 } } } } }

    Créez l'évaluateur :

    aws bedrock-agentcore-control create-evaluator \ --evaluator-name 'ResponseSimilarity' \ --level TRACE \ --description 'Evaluates how closely the agent response matches the expected response.' \ --evaluator-config file://response_similarity_config.json

Console

Vous pouvez créer des évaluateurs personnalisés à l'aide de l'interface visuelle de la AgentCore console Amazon Bedrock. Cette méthode fournit des formulaires guidés et une validation pour vous aider à configurer les paramètres de votre évaluateur.

Pour créer un évaluateur AgentCore personnalisé

  1. Ouvrez la AgentCore console Amazon Bedrock.

  2. Dans le volet de navigation de gauche, choisissez Evaluation. Choisissez l'une des méthodes suivantes pour créer un évaluateur personnalisé :

    • Choisissez Créer un évaluateur personnalisé sous la carte Comment ça marche.

    • Choisissez Évaluateurs personnalisés pour sélectionner la carte, puis choisissez Créer un évaluateur personnalisé.

  3. Dans Nom de l'évaluateur, entrez le nom de l'évaluateur personnalisé.

    1. (Facultatif) Dans Description de l'évaluateur, entrez une description pour l'évaluateur personnalisé.

  4. Pour Type d'évaluateur, choisissez l'une des options suivantes :

    • LLM-as-a-judge— Utilise un modèle de base pour évaluer les performances des agents. Suivez les étapes ci-dessous pour configurer la définition, le modèle et l'échelle de l'évaluateur.

    • Code-based— Utilise une fonction AWS Lambda pour évaluer par programmation les performances des agents. Pour l'ARN de la fonction Lambda, entrez l'ARN de votre fonction Lambda. Vous pouvez éventuellement définir le délai Lambda (1 à 300 secondes, 60 par défaut). Passez ensuite à l'étape du niveau d'évaluation.

  5. Pour la définition personnalisée de l'évaluateur, vous pouvez charger différents modèles pour les différents évaluateurs intégrés. Par défaut, le modèle Faithfulness est chargé. Modifiez le modèle en fonction de vos besoins.

    Note

    Si vous chargez un autre modèle, toutes les modifications apportées à votre définition d'évaluateur personnalisé existante seront remplacées.

  6. Pour le modèle d'évaluateur personnalisé, choisissez un modèle pris en charge en choisissant la barre de recherche du modèle à droite de la définition de l'évaluateur personnalisé. Vous pouvez choisir un modèle Amazon Bedrock Foundation sur le point de terminaison Amazon Bedrock Runtime ou sur le point de terminaison Amazon Bedrock Mantle. Pour plus d'informations sur les modèles pris en charge, consultez :

    • Modèles pris en charge

      1. (Facultatif) Pour définir les paramètres d'inférence du modèle, activez Régler la température, Régler P, Définir les jetons de sortie maximaux et Définir les séquences d'arrêt. Les paramètres d'inférence disponibles dépendent du modèle sélectionné. Pour un modèle de raisonnement, la console fournit l'effort de raisonnement Set au lieu de Set temperature et Set top P.

  7. Pour le type d'échelle de l'évaluateur, choisissez Définir l'échelle en tant que valeurs numériques ou Définir l'échelle en tant que valeurs de chaîne.

  8. Pour les définitions de l'échelle Evaluator, vous pouvez avoir un total de 20 définitions.

  9. Pour le niveau d'évaluation de l'évaluateur, choisissez l'une des options suivantes :

    • Séance — Évaluez l'ensemble des sessions de conversation.

    • Trace  : évaluez chaque trace individuelle.

    • Appel d'outil  : évaluez chaque appel d'outil.

  10. Choisissez Créer un évaluateur personnalisé pour créer l'évaluateur personnalisé.

Meilleures pratiques en matière d'évaluateurs personnalisés

La rédaction d'instructions bien structurées à l'intention des évaluateurs est essentielle pour des évaluations précises. Tenez compte des directives suivantes lorsque vous rédigez les instructions de l'évaluateur, que vous sélectionnez les niveaux de l'évaluateur et que vous choisissez des valeurs d'espace réservé.

  • Sélection du niveau d'évaluation : sélectionnez le niveau d'évaluation approprié en fonction de vos exigences en matière de coût, de latence et de performances. Choisissez entre le niveau de suivi (examine les réponses individuelles des agents), le niveau de l'outil (examine l'utilisation d'un outil spécifique) ou le niveau de session (examine les sessions d'interaction complètes). Votre choix doit correspondre aux objectifs du projet et aux contraintes de ressources.

  • Critères d'évaluation : définissez des dimensions d'évaluation claires et spécifiques à votre domaine. Utilisez l'approche mutuellement exclusive et collectivement exhaustive (MECE) pour vous assurer que chaque évaluateur a un champ d'application distinct. Cela évite le chevauchement des responsabilités en matière d'évaluation et garantit une couverture complète de tous les domaines d'évaluation.

  • Définition du rôle : Pour les instructions, commencez par définir le rôle modèle du juge en tant qu'évaluateur de performance. Une définition claire des rôles améliore les performances du modèle et évite toute confusion entre l'évaluation et l'exécution des tâches. Cela est particulièrement important lorsque vous travaillez avec différents modèles de juges.

  • Directives pédagogiques : créez des instructions d'évaluation claires et séquentielles. Lorsque vous faites face à des exigences complexes, décomposez-les en étapes simples et compréhensibles. Utilisez un langage précis pour garantir une évaluation cohérente dans toutes les instances.

  • Exemple d'intégration : dans vos instructions, incorporez 1 à 3 exemples pertinents montrant comment les humains évalueraient les performances des agents dans votre domaine. Chaque exemple doit inclure des paires d'entrée et de sortie correspondantes qui représentent avec précision les normes que vous attendez. Bien qu'ils soient facultatifs, ces exemples constituent de précieuses références de base.

  • Gestion du contexte : dans vos instructions, choisissez des espaces réservés au contexte de manière stratégique en fonction de vos besoins spécifiques. Trouvez le juste équilibre entre fournir suffisamment d'informations et éviter toute confusion chez l'évaluateur. Ajustez la profondeur du contexte en fonction des capacités et des limites de votre modèle d'évaluation.

  • Cadre de notation : choisissez entre une échelle binaire (0/1) ou une échelle de Likert (plusieurs niveaux). Définissez clairement la signification de chaque niveau de score. En cas de doute quant à l'échelle à utiliser, commencez par le système de notation binaire le plus simple.

  • Structure de sortie : Notre service inclut automatiquement une invite de standardisation à la fin de chaque instruction personnalisée de l'évaluateur. Cette invite applique deux champs de sortie : raison et score, le raisonnement étant toujours présenté avant le score pour garantir une évaluation basée sur la logique. N'incluez pas d'instructions de formatage de sortie dans les instructions d'origine de votre évaluateur afin d'éviter de confondre le modèle de jugement.