Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Integre las comprobaciones de razonamiento automatizadas en su aplicación

Después de implementar tu política de razonamiento automatizado en una barrera (consulteImplementación de la política de razonamiento automatizado en su aplicación), puedes usarla en tiempo de ejecución para validar las respuestas de la LLM y tomar medidas en función de los comentarios. En esta página, se explica cómo utilizar la API de validación, interpretar los resultados mediante programación e implementar patrones de integración comunes, como reescribir las respuestas no válidas y formular preguntas aclaratorias.

Las comprobaciones de razonamiento automatizadas solo funcionan en modo de detección: devuelven resultados y comentarios en lugar de bloquear el contenido. Tu aplicación es responsable de decidir qué hacer con los resultados: entregar la respuesta, reescribirla, pedir aclaraciones o volver a un comportamiento predeterminado.

Información general de la integración

En tiempo de ejecución, la integración sigue este flujo:

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
    

Los resultados de Automated Reasoning se devuelven a través de cualquier API que admita una configuración de Amazon Bedrock Guardrails:

Esta página se centra en la ApplyGuardrail API porque proporciona la mayor flexibilidad para implementar los patrones de reescritura y aclaración que se describen a continuación. Para obtener información sobre el uso de barandillas con las otras APIs, consulte Uso de una barandilla.

Ejemplo de chatbot de reescritura de código abierto

Para obtener una implementación completa y al estilo de producción de los patrones descritos en esta página, consulta las comprobaciones de razonamiento automático sobre cómo reescribir el chatbot. GitHub En este ejemplo de aplicación se muestra lo siguiente:

El ejemplo utiliza un Python/Flask backend con una interfaz de React y se comunica con Amazon Bedrock para la inferencia LLM y con Amazon Bedrock Guardrails para la validación a través de la API. ApplyGuardrail

Llame ApplyGuardrail con comprobaciones de razonamiento automatizadas

Usa la ApplyGuardrail API para validar el contenido comparándolo con tus barreras. La API acepta uno o más bloques de contenido y devuelve una evaluación que incluye los resultados del razonamiento automatizado.

Estructura de la solicitud

Ejemplo: valide una respuesta de LLM mediante el 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."
      }
    }
  ]'

Ejemplo: validar una respuesta LLM con 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))

Estructura de una respuesta

La ApplyGuardrail respuesta incluye una matriz. assessments Cada evaluación contiene un automatedReasoningPolicy objeto con una findings matriz. Cada hallazgo es de un tipo de unión; está presente exactamente una de las siguientes claves:

Para obtener una descripción detallada de cada tipo de hallazgo y sus campos, consulteHallazgos y resultados de la validación.

Interprete los hallazgos de AR en tiempo de ejecución

Para actuar de forma programática sobre los hallazgos del Razonamiento Automatizado, tu aplicación debe extraer el tipo de hallazgo, los detalles de la traducción y las reglas que las respaldan o contradicen. En las siguientes secciones se explica cómo analizar cada parte de un hallazgo.

Determine el tipo de hallazgo

Cada hallazgo es una unión: existe exactamente una clave. Compruebe qué clave existe para determinar el tipo de hallazgo:

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

Lea la traducción

La mayoría de los tipos de búsqueda incluyen un translation objeto que muestra cómo las comprobaciones de razonamiento automatizadas tradujeron la entrada del lenguaje natural en lógica formal. La traducción contiene:

Compruebe untranslatedPremises y untranslatedClaims comprenda el alcance de la validación. VALIDEl resultado solo cubre las afirmaciones traducidas; el contenido no traducido no se verifica.

Lee las reglas que respaldan o contradicen

Según el tipo de hallazgo, el hallazgo incluye reglas que explican el resultado:

Estas reglas y escenarios son las entradas clave para el patrón de reescritura descrito enReescribe las respuestas no válidas con comentarios de realidad aumentada.

Determine el resultado agregado

Una sola solicitud de validación puede arrojar varios resultados. Para determinar el resultado general, clasifique los hallazgos por gravedad y seleccione los peores. El orden de gravedad de peor a mejor es: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

Gestione los resultados de la validación en su aplicación

Utilice el resultado agregado para decidir qué hará su aplicación a continuación. En la siguiente tabla se resume la acción recomendada para cada tipo de resultado.

Reescribe las respuestas no válidas con comentarios de realidad aumentada

El patrón de integración más eficaz para las comprobaciones de razonamiento automatizadas es el ciclo de reescritura: cuando una respuesta es invalid osatisfiable, la aplicación crea un mensaje que incluye la respuesta original, los hallazgos específicos y las reglas de la política, y luego pide al LLM que reescriba la respuesta para que sea coherente con la política. La respuesta reescrita se valida de nuevo y el ciclo continúa hasta que la respuesta se alcanza valid o se alcanza un número máximo de iteraciones.

Flujo del bucle de reescritura

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
      

Construye el mensaje de reescritura

El mensaje de reescritura debe incluir tres datos extraídos de los hallazgos de la AR:

Ejemplo de plantilla de mensaje de reescritura:

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.

Mejores prácticas de reescritura

Haga preguntas aclaratorias

Cuando las comprobaciones de razonamiento automatizado translationAmbiguous satisfiable arrojen impossible resultados o resulten, es posible que el LLM no tenga suficiente información para reescribir la respuesta con precisión. En estos casos, la aplicación puede solicitar una aclaración al usuario y, a continuación, incorporar las respuestas en el siguiente intento de validación.

¿Cuándo pedir una aclaración

Patrón de aclaración

El flujo de clarificación funciona de la siguiente manera:

Ejemplo: generar preguntas aclaratorias a partir de un hallazgo 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.")

Cree un registro de auditoría

Los resultados del razonamiento automatizado proporcionan una prueba de validez matemáticamente verificable. En el caso de los sectores regulados y los escenarios de cumplimiento, esta prueba es un elemento diferenciador clave: se puede demostrar que la respuesta de la IA se verificó con arreglo a normas políticas específicas con asignaciones de variables específicas, y no solo se comparó con patrones o se evaluó probabilísticamente.

Para crear un registro de auditoría eficaz, registre la siguiente información para cada solicitud de validación:

Ejemplo: estructura de entradas del registro de auditoría

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