As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Integre verificações automatizadas de raciocínio em seu aplicativo

Depois de implantar sua política de raciocínio automatizado em uma grade de proteção (consulteImplantar uma política de raciocínio automatizado em uma aplicação), você pode usá-la em tempo de execução para validar as respostas do LLM e agir de acordo com o feedback. Esta página explica como chamar a API de validação, interpretar as descobertas de forma programática e implementar padrões de integração comuns, como reescrever respostas inválidas e fazer perguntas esclarecedoras.

As verificações automatizadas de raciocínio operam apenas no modo de detecção — elas retornam descobertas e feedback em vez de bloquear o conteúdo. Seu aplicativo é responsável por decidir o que fazer com as descobertas: fornecer a resposta, reescrevê-la, pedir esclarecimentos ou retornar a um comportamento padrão.

Visão geral da integração

Em tempo de execução, a integração segue esse fluxo:

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
    

As descobertas do Automated Reasoning são retornadas por meio de qualquer API que ofereça suporte a uma configuração do Amazon Bedrock Guardrails:

Esta página se concentra na ApplyGuardrail API porque ela fornece a maior flexibilidade para implementar os padrões de reescrita e esclarecimento descritos abaixo. Para obter informações sobre como usar grades de proteção com outras APIs, consulte Usar uma grade de proteção.

Exemplo de chatbot de reescrita de código aberto

Para uma implementação completa e em estilo de produção dos padrões descritos nesta página, consulte as verificações de raciocínio automatizado que reescrevem o chatbot em. GitHub Esse exemplo de aplicativo demonstra:

A amostra usa um Python/Flask back-end com um front-end React e se comunica com o Amazon Bedrock para inferência do LLM e com o Amazon Bedrock Guardrails para validação por meio da API. ApplyGuardrail

Ligue ApplyGuardrail com verificações automatizadas de raciocínio

Use a ApplyGuardrail API para validar o conteúdo em relação à sua grade de proteção. A API aceita um ou mais blocos de conteúdo e retorna uma avaliação que inclui descobertas de raciocínio automatizado.

Estrutura de solicitações

Exemplo: Validar uma resposta LLM usando o 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."
      }
    }
  ]'

Exemplo: Validar uma resposta LLM usando 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))

Estrutura de respostas

A ApplyGuardrail resposta inclui uma assessments matriz. Cada avaliação contém um automatedReasoningPolicy objeto com uma findings matriz. Cada descoberta é um tipo de união — exatamente uma das seguintes chaves está presente:

Para obter uma descrição detalhada de cada tipo de descoberta e seus campos, consulteDescobertas e resultados de validação.

Interprete as descobertas de AR em tempo de execução

Para agir programaticamente com base nas descobertas do Raciocínio Automatizado, seu aplicativo precisa extrair o tipo de descoberta, os detalhes da tradução e as regras de apoio ou contraditórias. As seções a seguir explicam como analisar cada parte de uma descoberta.

Determine o tipo de descoberta

Cada descoberta é uma união — exatamente uma chave está presente. Verifique qual chave existe para determinar o tipo de descoberta:

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

Leia a tradução

A maioria dos tipos de descoberta inclui um translation objeto que mostra como as verificações de raciocínio automatizado traduziram a entrada da linguagem natural em lógica formal. A tradução contém:

Verifique untranslatedPremises e untranslatedClaims entenda o escopo da validação. Um VALID resultado abrange apenas as declarações traduzidas — o conteúdo não traduzido não é verificado.

Leia as regras de apoio ou contraditórias

Dependendo do tipo de descoberta, a descoberta inclui regras que explicam o resultado:

Essas regras e cenários são as principais entradas para o padrão de reescrita descrito em. Reescreva respostas inválidas usando feedback de AR

Determine o resultado agregado

Uma única solicitação de validação pode retornar várias descobertas. Para determinar o resultado geral, classifique as descobertas por gravidade e selecione a pior. A ordem de severidade do pior para o melhor é: 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

Gerencie os resultados da validação em seu aplicativo

Use o resultado agregado para decidir o que seu aplicativo fará a seguir. A tabela a seguir resume a ação recomendada para cada tipo de resultado.

Reescreva respostas inválidas usando feedback de AR

O padrão de integração mais poderoso para verificações de raciocínio automatizado é o ciclo de reescrita: quando uma resposta é invalid ousatisfiable, seu aplicativo cria um prompt que inclui a resposta original, as descobertas específicas e as regras da política e, em seguida, solicita que o LLM reescreva a resposta para que seja consistente com a política. A resposta reescrita é validada novamente e o loop continua até que a resposta seja atingida valid ou o número máximo de iterações seja atingido.

Reescrevendo o fluxo do loop

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
      

Construa o prompt de reescrita

A solicitação de reescrita deve incluir três informações das descobertas do AR:

Exemplo de modelo de solicitação de reescrita:

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.

Reescrevendo as melhores práticas

Faça perguntas esclarecedoras

Quando as verificações de raciocínio automatizado retornam translationAmbiguous ou impossible resultam, o LLM pode não ter informações suficientes para reescrever a resposta com precisão. satisfiable Nesses casos, seu aplicativo pode pedir esclarecimentos ao usuário e, em seguida, incorporar as respostas na próxima tentativa de validação.

Quando pedir esclarecimentos

Padrão de esclarecimento

O fluxo de esclarecimento funciona da seguinte forma:

Exemplo: gerar perguntas esclarecedoras a partir de uma descoberta 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.")

Crie uma trilha de auditoria

As descobertas do raciocínio automatizado fornecem prova de validade matematicamente verificável. Para setores regulamentados e cenários de conformidade, essa prova é um diferencial importante: você pode demonstrar que uma resposta de IA foi verificada em relação a regras de política específicas com atribuições de variáveis específicas, não apenas com correspondência de padrões ou avaliada probabilisticamente.

Para criar uma trilha de auditoria eficaz, registre as seguintes informações para cada solicitação de validação:

Exemplo: estrutura de entrada do registro de auditoria

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