本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

在您的应用程序中集成自动推理检查

在护栏中部署自动推理策略后（请参阅在应用程序中部署自动推理策略），您可以在运行时使用它来验证 LLM 响应并根据反馈采取行动。本页介绍如何调用验证 API，如何以编程方式解释发现结果，以及如何实现常见的集成模式，例如重写无效的响应和询问澄清问题。

自动推理检查仅在检测模式下运行——它们返回结果和反馈，而不是屏蔽内容。您的应用程序负责决定如何处理调查结果：提供响应、重写响应、要求澄清或回退到默认行为。

集成概述

在运行时，集成遵循以下流程：

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
    

自动推理结果将通过任何支持 Amazon Bedrock Guardrails 配置的 API 返回：

本页重点介绍 ApplyGuardrail API，因为它为实现下述重写和澄清模式提供了最大的灵活性。有关将护栏与其他护栏一起使用的信息 APIs，请参阅使用护栏。

开源重写聊天机器人示例

有关本页描述的模式的完整生产风格实现，请参阅自动推理检查重写聊天机器人。 GitHub此示例应用程序演示：

该示例使用带有 React 前 Python/Flask 端的后端，并通过 API 与 Amazon Bedrock 通信进行法学硕士推断，与 Amazon Bedrock Guardrails 通信进行验证。ApplyGuardrail

ApplyGuardrail 使用自动推理检查致电

使用 ApplyGuardrail API 在您的护栏上验证内容。API 接受一个或多个内容块，并返回包含自动推理结果的评估。

请求结构

示例：使用验证 LLM 响应 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."
      }
    }
  ]'

示例：使用 Python (boto3) 验证 LLM 响应

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

响应结构

ApplyGuardrail响应包含一个assessments数组。每个评估都包含一个带有findings数组的automatedReasoningPolicy对象。每个发现都是一种联合类型——正好存在以下键之一：

有关每种查找结果类型及其字段的详细说明，请参见调查结果和验证结果。

在运行时解释 AR 结果

要以编程方式对自动推理结果采取行动，您的应用程序需要提取结果类型、翻译详细信息以及支持或相互矛盾的规则。以下各节说明了如何解析结果的每个部分。

确定查找类型

每个发现都是一个结合——只有一个钥匙存在。检查存在哪个密钥以确定查找类型：

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

阅读翻译

大多数查找类型都包含一个translation对象，该对象显示自动推理检查如何将自然语言输入转换为形式逻辑。翻译包含：

检查untranslatedPremisesuntranslatedClaims并了解验证的范围。VALID结果仅涵盖已翻译的声明，未翻译的内容未经过验证。

阅读支持或相互矛盾的规则

根据查找结果的类型，查找结果包括解释结果的规则：

这些规则和场景是中描述的重写模式的关键输入。使用 AR 反馈重写无效的回复

确定聚合结果

单个验证请求可以返回多个结果。要确定总体结果，请按严重程度对结果进行排序，然后选择最差的结果。从最差到最佳的严重性顺序为：TRANSLATION_AMBIGUOUSIMPOSSIBLE、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

处理应用程序中的验证结果

使用汇总结果来决定您的应用程序接下来要做什么。下表汇总了每种结果类型的建议操作。

使用 AR 反馈重写无效的回复

Automated Reasoning 检查最强大的集成模式是重写循环：当响应为invalid或时satisfiable，您的应用程序会构造一个包含原始响应、具体发现和策略规则的提示，然后要求 LLM 重写响应以使其与策略保持一致。再次验证重写的响应，循环将继续，直到响应达到valid或达到最大迭代次数。

重写循环流程

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
      

构造重写提示

重写提示应包含 AR 发现的三条信息：

重写提示模板示例：

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.

重写最佳实践

提出澄清问题

当自动推理检查返回translationAmbiguoussatisfiable、或impossible结果时，法学硕士可能没有足够的信息来准确地重写响应。在这些情况下，您的应用程序可以要求用户进行澄清，然后将答案纳入下一次验证尝试中。

何时要求澄清

澄清模式

澄清流程的工作原理如下：

示例：根据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.")

建立审计跟踪

自动推理结果提供了数学上可验证的有效性证据。对于受监管的行业和合规场景，这种证明是一个关键的差异化因素——你可以证明，人工智能响应是根据具有特定变量分配的特定政策规则进行验证的，而不仅仅是模式匹配或概率评估。

要建立有效的审计跟踪，请记录每个验证请求的以下信息：

示例：审计日志条目结构

{
  "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
}