Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Integrieren Sie automatisierte Argumentationsprüfungen in Ihre Anwendung

Nachdem Sie Ihre Richtlinie für automatisiertes Denken in einer Leitplanke implementiert haben (sieheImplementieren der Automated-Reasoning-Richtlinie in die Anwendung), können Sie sie zur Laufzeit verwenden, um LLM-Antworten zu validieren und auf das Feedback zu reagieren. Auf dieser Seite wird erklärt, wie Sie die Validierungs-API aufrufen, die Ergebnisse programmgesteuert interpretieren und gängige Integrationsmuster wie das Umschreiben ungültiger Antworten und das Stellen klärender Fragen implementieren.

Automatisierte Prüfungen zur Argumentation funktionieren nur im Erkennungsmodus — sie geben Ergebnisse und Feedback zurück, anstatt Inhalte zu blockieren. Ihre Anwendung ist dafür verantwortlich, zu entscheiden, was mit den Ergebnissen geschehen soll: die Antwort zuzustellen, sie neu zu schreiben, um Klarstellung zu bitten oder auf ein Standardverhalten zurückzugreifen.

Übersicht über die Integration

Zur Laufzeit folgt die Integration diesem Ablauf:

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
    

Ergebnisse von Automated Reasoning werden über jede API zurückgegeben, die eine Amazon Bedrock Guardrails-Konfiguration unterstützt:

Diese Seite konzentriert sich auf die ApplyGuardrail API, da sie die größte Flexibilität bei der Implementierung der unten beschriebenen Umschreib- und Klarstellungsmuster bietet. Informationen zur Verwendung von Leitplanken zusammen mit anderen APIs finden Sie unter Verwenden einer Leitplanke.

Beispiel für einen Open-Source-Chatbot zum Umschreiben

Eine vollständige Implementierung der auf dieser Seite beschriebenen Muster im Produktionsstil finden Sie unter Automated Reasoning checks rewriting chatbot. GitHub Diese Beispielanwendung demonstriert:

Das Beispiel verwendet ein Python/Flask Backend mit einem React-Frontend und kommuniziert mit Amazon Bedrock für LLM-Inferenz und Amazon Bedrock Guardrails zur Validierung über die API. ApplyGuardrail

Rufen Sie an, ApplyGuardrail bei dem Automated Reasoning geprüft wird

Verwenden Sie die ApplyGuardrail API, um Inhalte anhand Ihrer Leitplanke zu validieren. Die API akzeptiert einen oder mehrere Inhaltsblöcke und gibt eine Bewertung zurück, die Ergebnisse von Automated Reasoning beinhaltet.

Struktur der Anfrage

Beispiel: Validieren Sie eine LLM-Antwort mit dem 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."
      }
    }
  ]'

Beispiel: Validieren Sie eine LLM-Antwort mit 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))

Struktur der Antwort

Die ApplyGuardrail Antwort umfasst ein assessments Array. Jede Bewertung enthält ein automatedReasoningPolicy Objekt mit einem findings Array. Bei jedem Ergebnis handelt es sich um einen Kombinationstyp — genau einer der folgenden Schlüssel ist vorhanden:

Eine ausführliche Beschreibung der einzelnen Ergebnisarten und ihrer Felder finden Sie unterErgebnisse und Validierungsergebnisse.

Interpretieren Sie AR-Ergebnisse zur Laufzeit

Um programmatisch auf die Ergebnisse von Automated Reasoning reagieren zu können, muss Ihre Anwendung den Befundtyp, die Übersetzungsdetails und die unterstützenden oder widersprüchlichen Regeln extrahieren. In den folgenden Abschnitten wird erklärt, wie die einzelnen Teile eines Ergebnisses analysiert werden.

Ermitteln Sie den Befundtyp

Jeder Befund ist eine Vereinigung — genau ein Schlüssel ist vorhanden. Prüfen Sie, welcher Schlüssel existiert, um den Befundtyp zu bestimmen:

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

Lesen Sie die Übersetzung

Die meisten Befundtypen enthalten ein translation Objekt, das zeigt, wie automatische Argumentationsprüfungen die Eingabe in natürlicher Sprache in formale Logik übersetzt haben. Die Übersetzung enthält:

Prüfen untranslatedPremises und untranslatedClaims verstehen Sie den Umfang der Validierung. Ein VALID Ergebnis deckt nur die übersetzten Ansprüche ab — unübersetzte Inhalte werden nicht verifiziert.

Lesen Sie die unterstützenden oder widersprüchlichen Regeln

Je nach Art des Ergebnisses enthält das Ergebnis Regeln, die das Ergebnis erklären:

Diese Regeln und Szenarien sind die wichtigsten Inputs für das unter beschriebene Umschreibmuster. Schreiben Sie ungültige Antworten mithilfe von AR-Feedback um

Ermitteln Sie das Gesamtergebnis

Eine einzelne Überprüfungsanfrage kann mehrere Ergebnisse zurückgeben. Um das Gesamtergebnis zu ermitteln, sortieren Sie die Ergebnisse nach Schweregrad und wählen Sie das schlechteste aus. Die Reihenfolge des Schweregrads vom schlechtesten zum besten lautet: 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

Behandeln Sie die Validierungsergebnisse in Ihrer Anwendung

Verwenden Sie das Gesamtergebnis, um zu entscheiden, was Ihre Anwendung als Nächstes tun soll. In der folgenden Tabelle sind die empfohlenen Maßnahmen für jeden Ergebnistyp zusammengefasst.

Schreiben Sie ungültige Antworten mithilfe von AR-Feedback um

Das leistungsstärkste Integrationsmuster für automatische Argumentationsprüfungen ist die Umschreibschleife: Wenn eine Antwort invalid oder lautet, erstellt Ihre Anwendung eine Aufforderungsatisfiable, die die ursprüngliche Antwort, die spezifischen Ergebnisse und die Richtlinienregeln enthält, und fordert dann den LLM auf, die Antwort neu zu schreiben, damit sie mit der Richtlinie konsistent ist. Die umgeschriebene Antwort wird erneut validiert, und die Schleife wird fortgesetzt, bis die Antwort vorliegt valid oder eine maximale Anzahl von Iterationen erreicht ist.

Der Schleifenfluss wird neu geschrieben

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
      

Konstruieren Sie die Aufforderung zum Umschreiben

Die Aufforderung zum Umschreiben sollte drei Informationen aus den AR-Ergebnissen enthalten:

Beispiel für eine Vorlage für eine Aufforderung zum Umschreiben:

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.

Bewährte Methoden zum Umschreiben

Stellen Sie klärende Fragen

Wenn Automated Reasoning impossible Ergebnisse oder Ergebnisse überprüft translationAmbiguoussatisfiable, verfügt das LLM möglicherweise nicht über genügend Informationen, um die Antwort korrekt neu zu formulieren. In diesen Fällen kann Ihre Anwendung den Benutzer um eine Klarstellung bitten und die Antworten dann in den nächsten Validierungsversuch einfließen lassen.

Wann sollten Sie um eine Klarstellung bitten

Muster der Klärung

Der Klärungsablauf funktioniert wie folgt:

Beispiel: Generieren Sie anhand eines Ergebnisses klärende satisfiable Fragen

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

Erstellen Sie einen Prüfpfad

Die Ergebnisse von Automated Reasoning liefern einen mathematisch überprüfbaren Validitätsnachweis. Für regulierte Branchen und Compliance-Szenarien ist dieser Nachweis ein wichtiges Unterscheidungsmerkmal. Sie können nachweisen, dass eine KI-Reaktion anhand bestimmter politischer Regeln mit spezifischen Variablenzuweisungen verifiziert und nicht nur anhand von Mustern oder Wahrscheinlichkeiten bewertet wurde.

Um einen effektiven Prüfpfad zu erstellen, protokollieren Sie die folgenden Informationen für jede Überprüfungsanfrage:

Beispiel: Struktur der Audit-Logeinträge

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