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.

Intégrez des contrôles de raisonnement automatisés dans votre application

Après avoir déployé votre politique de raisonnement automatisé dans un garde-corps (voirDéploiement de votre politique de raisonnement automatisé dans votre application), vous pouvez l'utiliser lors de l'exécution pour valider les réponses LLM et agir en fonction des commentaires. Cette page explique comment appeler l'API de validation, interpréter les résultats par programmation et implémenter des modèles d'intégration courants tels que la réécriture de réponses non valides et la pose de questions de clarification.

Les contrôles de raisonnement automatisés fonctionnent uniquement en mode détection : ils renvoient des résultats et des commentaires au lieu de bloquer le contenu. Votre application est chargée de décider quoi faire avec les résultats : envoyer la réponse, la réécrire, demander des éclaircissements ou revenir au comportement par défaut.

Présentation de l’intégration

Au moment de l'exécution, l'intégration suit le flux suivant :

User question ──► LLM generates response ──► ApplyGuardrail validates response
                                                        │
                                              ┌─────────┴─────────┐
                                              │                   │
                                            VALID              Not VALID
                                              │                   │
                                              ▼                   ▼
                                        Serve response     Inspect findings
                                        to user                  │
                                                        ┌────────┴────────┐
                                                        │                 │
                                                   OTHER FINDING     TRANSLATION_
                                                      TYPES       AMBIGUOUS / SATISFIABLE
                                                        │                 │
                                                        ▼                 ▼
                                                   Rewrite using    Ask user for
                                                   AR feedback      clarification
                                                        │                 │
                                                        ▼                 ▼
                                                   Validate again   Validate with
                                                                    clarified input
    

Les résultats du raisonnement automatisé sont renvoyés via n'importe quelle API compatible avec une configuration Amazon Bedrock Guardrails :

Cette page se concentre sur l'ApplyGuardrailAPI car elle offre la plus grande flexibilité pour implémenter les modèles de réécriture et de clarification décrits ci-dessous. Pour plus d'informations sur l'utilisation de garde-corps avec l'autre APIs, voir Utiliser un garde-corps.

Exemple de chatbot de réécriture open source

Pour une implémentation complète, dans le style de production, des modèles décrits sur cette page, consultez le chatbot de réécriture sur le raisonnement automatisé. GitHub Cet exemple d'application illustre :

L'exemple utilise un Python/Flask backend avec une interface React et communique avec Amazon Bedrock pour l'inférence LLM et Amazon Bedrock Guardrails pour la validation via l'API. ApplyGuardrail

Appel ApplyGuardrail avec contrôles de raisonnement automatisés

Utilisez l'ApplyGuardrailAPI pour valider le contenu par rapport à votre garde-fou. L'API accepte un ou plusieurs blocs de contenu et renvoie une évaluation qui inclut les résultats du raisonnement automatisé.

Structure de la demande

Exemple : valider une réponse LLM à l'aide du AWS CLI

aws bedrock-runtime apply-guardrail \
  --guardrail-identifier "your-guardrail-id" \
  --guardrail-version "1" \
  --source OUTPUT \
  --content '[
    {
      "text": {
        "text": "User: Am I eligible for parental leave if I have been working here for 2 years full-time?\nAssistant: Yes, you are eligible for parental leave."
      }
    }
  ]'

Exemple : valider une réponse LLM à l'aide de Python (boto3)

import boto3
import json

bedrock_runtime = boto3.client("bedrock-runtime", region_name="us-east-1")

response = bedrock_runtime.apply_guardrail(
    guardrailIdentifier="your-guardrail-id",
    guardrailVersion="1",
    source="OUTPUT",
    content=[
        {
            "text": {
                "text": (
                    "User: Am I eligible for parental leave if I have been "
                    "working here for 2 years full-time?\n"
                    "Assistant: Yes, you are eligible for parental leave."
                )
            }
        }
    ],
)

# The AR findings are in the assessments
for assessment in response.get("assessments", []):
    ar_assessment = assessment.get("automatedReasoningPolicy", {})
    findings = ar_assessment.get("findings", [])
    for finding in findings:
        # Each finding is a union — exactly one key is present
        # Possible keys: valid, invalid, satisfiable, impossible,
        #                translationAmbiguous, tooComplex, noTranslations
        print(json.dumps(finding, indent=2, default=str))

Structure de réponse

La ApplyGuardrail réponse inclut un assessments tableau. Chaque évaluation contient un automatedReasoningPolicy objet associé à un findings tableau. Chaque résultat est un type d'union ; exactement l'une des clés suivantes est présente :

Pour une description détaillée de chaque type de recherche et de ses champs, voirConstatations et résultats de validation.

Interpréter les résultats de la réalité augmentée lors de

Pour agir sur les résultats du raisonnement automatisé de manière programmatique, votre application doit extraire le type de recherche, les détails de la traduction et les règles sous-jacentes ou contradictoires. Les sections suivantes expliquent comment analyser chaque partie d'un résultat.

Déterminer le type de recherche

Chaque résultat est une union : une seule clé est présente. Vérifiez quelle clé existe pour déterminer le type de recherche :

def get_finding_type(finding):
    """Return the finding type and its data from an AR finding union."""
    for finding_type in [
        "valid", "invalid", "satisfiable", "impossible",
        "translationAmbiguous", "tooComplex", "noTranslations"
    ]:
        if finding_type in finding:
            return finding_type, finding[finding_type]
    return None, None

Lire la traduction

La plupart des types de recherche incluent un translation objet qui montre comment les contrôles de raisonnement automatisés ont traduit l'entrée en langage naturel en logique formelle. La traduction contient :

Vérifiez untranslatedPremises et untranslatedClaims comprenez l'étendue de la validation. Un VALID résultat ne couvre que les demandes traduites ; le contenu non traduit n'est pas vérifié.

Lisez les règles complémentaires ou contradictoires

Selon le type de recherche, la recherche inclut des règles expliquant le résultat :

Ces règles et scénarios sont les entrées clés du modèle de réécriture décrit dansRéécrivez les réponses non valides à l'aide des commentaires AR.

Déterminer le résultat global

Une seule demande de validation peut renvoyer plusieurs résultats. Pour déterminer le résultat global, triez les résultats par gravité et sélectionnez le pire. L'ordre de gravité du pire au meilleur est :TRANSLATION_AMBIGUOUS,IMPOSSIBLE,INVALID,SATISFIABLE,VALID.

SEVERITY_ORDER = {
    "tooComplex": 0,
    "translationAmbiguous": 0,
    "impossible": 1,
    "invalid": 2,
    "satisfiable": 3,
    "valid": 4,
    "noTranslations": 5, 
}

def get_aggregate_result(findings):
    """Return the worst finding type from a list of findings."""
    worst = None
    worst_severity = float("inf")
    for finding in findings:
        finding_type, _ = get_finding_type(finding)
        severity = SEVERITY_ORDER.get(finding_type, 0)
        if severity < worst_severity:
            worst_severity = severity
            worst = finding_type
    return worst

Gérez les résultats de validation dans votre application

Utilisez le résultat agrégé pour décider de la prochaine action de votre application. Le tableau suivant récapitule les actions recommandées pour chaque type de résultat.

Réécrivez les réponses non valides à l'aide des commentaires AR

Le modèle d'intégration le plus puissant pour les contrôles de raisonnement automatisés est la boucle de réécriture : lorsqu'une réponse est invalid ousatisfiable, votre application crée une invite qui inclut la réponse d'origine, les résultats spécifiques et les règles de politique, puis demande au LLM de réécrire la réponse pour qu'elle soit cohérente avec la politique. La réponse réécrite est à nouveau validée et la boucle continue jusqu'à ce que la réponse soit atteinte valid ou qu'un nombre maximal d'itérations soit atteint.

Réécriture du flux de boucle

LLM generates initial response
         │
         ▼
Validate with ApplyGuardrail ◄──────────────────┐
         │                                       │
         ▼                                       │
   ┌─────┴─────┐                                 │
   │           │                                 │
 VALID     Not VALID                             │
   │           │                                 │
   ▼           ▼                                 │
 Done    Construct rewriting prompt              │
         with findings + rules                   │
              │                                  │
              ▼                                  │
         LLM rewrites response                   │
              │                                  │
              ▼                                  │
         Max iterations? ──── No ────────────────┘
              │
             Yes
              │
              ▼
         Return best response
         with warning
      

Construire l'invite de réécriture

L'invite de réécriture doit inclure trois informations issues des résultats de l'AR :

Exemple de modèle d'invite de réécriture :

The following response was checked against our policy and found to be
{finding_type}.

Original response:
{original_response}

The validation found the following issue:
- Premises (what was understood from the input): {premises}
- Claims (what was asserted): {claims}
- Contradicting rules: {contradicting_rules}

Please rewrite the response so that it is consistent with the policy document. 
Keep the same helpful tone and answer the user's question
accurately based on the rules. If you cannot provide an accurate answer
without more information, explain what additional information is needed.

Meilleures pratiques en matière de réécriture

Posez des questions de clarification

Lorsque le raisonnement automatisé vérifie le retour ou les impossible résultats translationAmbiguoussatisfiable, le LLM peut ne pas disposer de suffisamment d'informations pour réécrire la réponse avec précision. Dans ces cas, votre application peut demander des éclaircissements à l'utilisateur, puis intégrer les réponses lors de la prochaine tentative de validation.

Quand demander des éclaircissements

Schéma de clarification

Le flux de clarification fonctionne comme suit :

Exemple : générer des questions de clarification à partir d'une constatation satisfiable

def generate_clarifying_questions(finding_data, user_question):
    """Ask the LLM to generate clarifying questions from a SATISFIABLE finding."""
    claims_true = json.dumps(
        finding_data.get("claimsTrueScenario", {}), indent=2, default=str
    )
    claims_false = json.dumps(
        finding_data.get("claimsFalseScenario", {}), indent=2, default=str
    )

    prompt = (
        f"A user asked: {user_question}\n\n"
        f"The answer is correct when these conditions hold:\n{claims_true}\n\n"
        f"But incorrect when these conditions hold:\n{claims_false}\n\n"
        f"Generate 1-3 short, specific questions to ask the user to determine "
        f"which conditions apply to their situation. Format each question on "
        f"its own line."
    )

    return generate_response(prompt, "You are a helpful assistant.")

Créez une piste d'audit

Les résultats du raisonnement automatisé fournissent une preuve de validité mathématiquement vérifiable. Pour les secteurs réglementés et les scénarios de conformité, cette preuve est un facteur de différenciation clé : vous pouvez démontrer qu'une réponse de l'IA a été vérifiée par rapport à des règles politiques spécifiques avec des affectations de variables spécifiques, et pas simplement selon des modèles ou évaluée de manière probabiliste.

Pour créer une piste d'audit efficace, enregistrez les informations suivantes pour chaque demande de validation :

Exemple : structure d'entrée du journal d'audit

{
  "timestamp": "2025-07-21T14:30:00Z",
  "request_id": "req-abc123",
  "guardrail_id": "your-guardrail-id",
  "guardrail_version": "1",
  "user_question": "Am I eligible for parental leave?",
  "llm_response": "Yes, you are eligible for parental leave.",
  "validation_result": "valid",
  "findings": [
    {
      "type": "valid",
      "premises": "isFullTime = true, tenureMonths = 24",
      "claims": "eligibleForParentalLeave = true",
      "supporting_rules": ["A1B2C3D4E5F6"]
    }
  ],
  "action_taken": "served_response",
  "rewrite_iterations": 0
}