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.

Wie werden Inhalte mit automatisierten Argumentationsprüfungen bewertet

Automatisierte Prüfungen zur Argumentation übersetzen die von Ihnen eingereichten Inhalte in eine logische Implikation — eine „if/then" Beziehung — und überprüfen dann, ob diese Implikation mit Ihren Richtlinien übereinstimmt. Aus der Übersetzung ergeben sich zwei Arten von logischen Aussagen:

Automatisierte Begründungsprüfungen entscheiden bei der Übersetzung des Inhalts, welche Aussagen Prämissen und welche Behauptungen sind — die Aufteilung wird nicht direkt aus den Eingabefeldern übernommen. Sie kontrollieren über die API, ob jeder Inhalt als benutzerseitige Eingabe (eine Frage oder eine angegebene Bedingung) oder als Eingabe durch einen Agenten (eine zu validierende Antwort) eingegeben wird. Das query Qualifier kennzeichnet Inhalte als benutzerseitig guardContent (oder Text ohne Tags) als agentenseitig und wird von automatisierten Argumentationsprüfungen ignoriert. groundingSource Die Übersetzung leitet dann die Prämissen und Behauptungen aus den kombinierten Eingaben ab.

Ob und wie Sie Inhalte taggen müssen, hängt von der API ab, die Sie verwenden.

Hauptunterschiede zwischen APIs

Übersicht über die Integration

Zur Laufzeit folgt die Integration diesem Ablauf:

User question ──► LLM generates response ──► Validate 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:

Rufen Sie ApplyGuardrail mit automatisierten Argumentationsüberprüfungen an

ApplyGuardrailbewertet den gesamten Inhalt, den Sie bestanden haben. Das Tagging ist optional: Standardmäßig wird jeder Inhaltsblock als agentenseitiger Inhalt (Anspruch) behandelt und anhand Ihrer Richtlinienregeln validiert. Dies ist der einfachste Integrationspfad. Um automatisierten Argumentationsprüfungen zusätzlichen Kontext zu geben, können Sie einen Inhaltsblock so einrichtenqualifiers, dass er als benutzerseitige Eingabe () markiert wird. query Im Gegensatz zu Converse und InvokeModel ApplyGuardrail fügt keine Musterantwort für Sie an, sodass der von Ihnen eingereichte Inhalt mindestens einen Anspruchsblock enthalten muss. Andernfalls gibt die Anfrage a zurück. ValidationException

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.

Rufen Sie Converse mit automatisierten Argumentationsprüfungen auf

Automatisierte Reasoning-Checks werden bei einer Converse Anfrage nur ausgeführt, wenn die Anfrage mindestens einen Block umfasst. guardContent Eine Anfrage, die nur Klartext sendet, text führt keine automatischen Argumentationsprüfungen durch.

Nur Klartext (automatische Argumentationsprüfungen wurden übersprungen)

Wenn in Ihrer Converse Anfrage nur einfache text Blöcke (keine guardContent Blöcke) verwendet werden, ist der Text nicht für die Bewertung von Leitplanken gekennzeichnet, sodass automatische Argumentationsprüfungen nichts zu bewerten haben und übersprungen werden:

{
  "messages": [{"role": "user", "content": [{"text": "Apply a 20% discount to my order"}]}]
}

Diese Anfrage wird zurückgegeben. automatedReasoningPolicyUnits: 0 Andere Richtlinien (Inhalt, Thema, Wort und vertrauliche Informationen) bewerten den Inhalt weiterhin. Lediglich automatische Argumentationsprüfungen werden übersprungen. Um automatische Argumentationsprüfungen durchzuführen, verwenden Sie einen guardContent Block, wie im nächsten Abschnitt gezeigt.

Verwenden von GuardContent-Blöcken

Um automatische Argumentationsprüfungen durchzuführenConverse, packen Sie den Inhalt, den Sie bewerten möchten, in einen guardContent Block ein und legen Sie die zugehörigen Qualifizierer fest. Auf diese Weise kennzeichnen Sie, welche Inhalte benutzerseitig und welche agentenseitig sind.

Die folgende Tabelle zeigt, wie jedes Kriterium Inhalte für automatische Argumentationsprüfungen kennzeichnet.

Der Qualifier legt nur fest, ob der Inhalt benutzer- oder agentenseitig ist. Automatisierte Argumentationsprüfungen leiten bei der Übersetzung der kombinierten Eingaben die tatsächlichen Prämissen und Behauptungen ab. Für einen Block, für den keine Qualifikatoren angegeben wurden, ist standardmäßig (agentenseitig) voreingestellt. guard_content Sie können mehrere Qualifizierer für einen Block angeben. Die Prioritätsreihenfolge ist. guard_content > query > grounding_source

Beispiel: Rufen Sie Converse mit den Qualifikationsmerkmalen für Automated Reasoning auf und verwenden Sie den AWS CLI

aws bedrock-runtime converse \
  --model-id "model-id" \
  --guardrail-config '{
    "guardrailIdentifier": "your-guardrail-id",
    "guardrailVersion": "1",
    "trace": "enabled"
  }' \
  --messages '[
    {
      "role": "user",
      "content": [
        {
          "guardContent": {
            "text": {
              "text": "Apply a 20% discount to my order and confirm it is done.",
              "qualifiers": ["query"]
            }
          }
        }
      ]
    }
  ]'

Wenn die Prüfungen für automatisiertes Denken ausgeführt werden

In der folgenden Tabelle wird zusammengefasst, ob für jede Converse Anforderungsform Prüfungen zum automatisierten Denken ausgeführt werden. In jedem Fall, in dem sie ausgeführt werden, wird die Antwort des Modells als Block auf Agentenseite (Anspruch) angehängt.

Anruf InvokeModel mit automatischen Argumentationsprüfungen

Funktionsweise

InvokeModelerfordert zwei Dinge für automatische Argumentationsprüfungen:

Das XML-Tag-Format lautet wie folgt:

<amazon-bedrock-guardrails-QUALIFIER_SUFFIX>text</amazon-bedrock-guardrails-QUALIFIER_SUFFIX>

Wobei Folgendes gilt:

Kennzeichnen Sie Rollen für automatische Argumentationsprüfungen

Der Qualifier legt nur fest, ob es sich bei dem markierten Text um eine benutzer- oder agentenseitige Eingabe handelt. Automatisierte Argumentationsprüfungen leiten die Prämissen und Behauptungen ab, wenn sie die kombinierte Eingabe übersetzen. Kennzeichnen Sie die Benutzereingabeaufforderung mitquery, um den Prüfungen einen Kontext zu geben. Die Ausgabe des Modells wird automatisch als agentenseitiger Block (Claim) angehängt. Es reicht also, die Eingabeaufforderung mit query allein zu kennzeichnen, damit die Prüfungen ausgeführt werden können.

Multi-tag Rangfolge- und Verschachtelungsregeln

Ein einzelnes Textsegment kann in mehrere verschachtelte Tag-Typen eingeschlossen werden. Wenn mehrere Tags auf denselben Inhalt zutreffen, bestimmt der Vorrang die Rolle des automatisierten Denkens:. guardContent > query > groundingSource Wenn ein Inhalt guardContent sowohl mit als auch gekennzeichnet istquery, wird er als Anspruch behandelt.

Es gelten die folgenden Verschachtelungsregeln:

Beispiel: Anruf InvokeModel mit Automated Reasoning-Tags unter Verwendung von AWS CLI

aws bedrock-runtime invoke-model \
  --model-id "model-id" \
  --guardrail-identifier "your-guardrail-id" \
  --guardrail-version "1" \
  --trace "ENABLED" \
  --cli-binary-format raw-in-base64-out \
  --body '{
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 256,
    "amazon-bedrock-guardrailConfig": {
      "tagSuffix": "arp"
    },
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "<amazon-bedrock-guardrails-query_arp>Apply a 20% discount to my order and confirm it is done.</amazon-bedrock-guardrails-query_arp>"
          }
        ]
      }
    ]
  }' \
  output.json

Diese Anfrage kehrt zurückautomatedReasoningPolicyUnits: 1, wobei die Ergebnisse von Automated Reasoning im Trace enthalten sind.

Standardverhalten (ohne Tags)

Dieselbe Anfrage ohne die XML-Tags verwendet Klartext:

"text": "Apply a 20% discount to my order and confirm it is done."

Diese Anfrage kehrt zurück automatedReasoningPolicyUnits: 0 — Automatisierte Argumentationsprüfungen wurden nicht ausgeführt, und es wurde kein Fehler ausgelöst. Die Leitplanke bewertet weiterhin andere Richtlinien (Inhalt, Thema, Wort und vertrauliche Informationen), aber automatische Argumentationsprüfungen werden vollständig übersprungen.

Interpretieren Sie die Ergebnisse von Automated Reasoning 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 Sie den Umfang der Validierung untranslatedPremises und untranslatedClaims machen Sie sich ein Bild davon. 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: translationAmbiguousimpossible,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.")

Open-source Beispiel für einen Chatbot neu schreiben

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

Erstellen Sie einen Audit-Trail

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
}