Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Integrasikan pemeriksaan Penalaran Otomatis dalam aplikasi Anda

Setelah menerapkan kebijakan Penalaran Otomatis di pagar pembatas (lihatTerapkan kebijakan Penalaran Otomatis Anda di aplikasi Anda), Anda dapat menggunakannya saat runtime untuk memvalidasi respons LLM dan bertindak berdasarkan umpan balik. Halaman ini menjelaskan cara memanggil API validasi, menafsirkan temuan secara terprogram, dan menerapkan pola integrasi umum seperti menulis ulang tanggapan yang tidak valid dan mengajukan pertanyaan klarifikasi.

Pemeriksaan Penalaran Otomatis hanya beroperasi dalam mode deteksi — mereka mengembalikan temuan dan umpan balik daripada memblokir konten. Aplikasi Anda bertanggung jawab untuk memutuskan apa yang harus dilakukan dengan temuan: menyajikan tanggapan, menulis ulang, meminta klarifikasi, atau kembali ke perilaku default.

Bagaimana pemeriksaan Penalaran Otomatis mengevaluasi konten

Pemeriksaan Penalaran Otomatis menerjemahkan konten yang Anda kirimkan ke dalam implikasi logis - hubungan “if/then” - dan kemudian periksa implikasi tersebut terhadap aturan kebijakan Anda. Terjemahan menghasilkan dua jenis pernyataan logis:

Pemeriksaan Penalaran Otomatis menentukan pernyataan mana yang merupakan premis dan mana yang merupakan klaim saat menerjemahkan konten — pemisahan tidak diambil langsung dari bidang input. Apa yang Anda kontrol melalui API adalah apakah setiap bagian konten masuk sebagai input sisi pengguna (pertanyaan atau kondisi yang dinyatakan) atau input sisi agen (respons untuk memvalidasi). queryKualifikasi menandai konten sebagai sisi pengguna; guardContent (atau teks yang tidak ditandai) menandainya sebagai sisi agen; groundingSource diabaikan oleh pemeriksaan Penalaran Otomatis. Terjemahan kemudian mendapatkan premis dan klaim dari input gabungan.

Apakah Anda harus menandai konten, dan bagaimana, tergantung pada API yang Anda gunakan.

Perbedaan utama antara API

Ikhtisar integrasi

Saat runtime, integrasi mengikuti alur ini:

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
    

Temuan Penalaran Otomatis dikembalikan melalui API apa pun yang mendukung konfigurasi Amazon Bedrock Guardrails:

Panggilan ApplyGuardrail dengan pemeriksaan Penalaran Otomatis

ApplyGuardrailmengevaluasi semua konten yang Anda lewati. Penandaan bersifat opsional: secara default setiap blok konten diperlakukan sebagai konten pihak agen (klaim) dan divalidasi berdasarkan aturan kebijakan Anda, yang merupakan jalur integrasi paling sederhana. Untuk memberikan Penalaran Otomatis memeriksa konteks tambahan, Anda dapat mengatur qualifiers blok konten untuk menandainya sebagai input sisi pengguna ()query. Tidak seperti Converse danInvokeModel, ApplyGuardrail tidak menambahkan respons model untuk Anda, sehingga konten yang Anda kirimkan harus menyertakan setidaknya satu blok klaim; jika tidak, permintaan akan mengembalikan file. ValidationException

Struktur permintaan

Contoh: Validasi respons LLM menggunakan 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."
      }
    }
  ]'

Contoh: Validasi respons LLM menggunakan 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 respons

ApplyGuardrailResponsnya mencakup assessments array. Setiap penilaian berisi automatedReasoningPolicy objek dengan findings array. Setiap temuan adalah tipe gabungan — persis salah satu kunci berikut hadir:

Untuk penjelasan rinci tentang setiap jenis temuan dan bidangnya, lihatTemuan dan hasil validasi.

Hubungi Converse dengan pemeriksaan Penalaran Otomatis

Pemeriksaan Penalaran Otomatis berjalan berdasarkan Converse permintaan hanya jika permintaan menyertakan setidaknya satu guardContent blok. Permintaan yang hanya mengirim biasa text tidak menjalankan pemeriksaan Penalaran Otomatis.

Hanya teks biasa (Pemeriksaan Penalaran Otomatis dilewati)

Jika Converse permintaan Anda hanya menggunakan text blok biasa (tanpa guardContent blok), teks tidak diberi tag untuk evaluasi pagar pembatas, jadi pemeriksaan Penalaran Otomatis tidak perlu dievaluasi dan dilewati:

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

Permintaan ini kembaliautomatedReasoningPolicyUnits: 0. Kebijakan pagar pembatas lainnya (konten, topik, kata, dan informasi sensitif) masih mengevaluasi konten; hanya pemeriksaan Penalaran Otomatis yang dilewati. Untuk menjalankan pemeriksaan Penalaran Otomatis, gunakan guardContent blok seperti yang ditunjukkan di bagian berikutnya.

Menggunakan blok GuardContent

Untuk menjalankan pemeriksaan Penalaran OtomatisConverse, bungkus konten yang ingin Anda evaluasi dalam satu guardContent blok dan atur kualifikasinya. Ini adalah bagaimana Anda menandai konten mana yang merupakan sisi pengguna dan mana yang merupakan sisi agen.

Tabel berikut menunjukkan bagaimana setiap qualifier menandai konten untuk pemeriksaan Penalaran Otomatis.

Kualifikasi hanya menetapkan apakah konten adalah sisi pengguna atau sisi agen; Pemeriksaan Penalaran Otomatis memperoleh premis dan klaim aktual saat mereka menerjemahkan input gabungan. Blok tanpa kualifikasi yang ditentukan default ke (sisi agen). guard_content Anda dapat menentukan beberapa kualifikasi pada satu blok. Urutan prioritas adalah. guard_content > query > grounding_source

Contoh: Panggil Converse dengan kualifikasi Penalaran Otomatis menggunakan 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"]
            }
          }
        }
      ]
    }
  ]'

Saat pemeriksaan Penalaran Otomatis berjalan

Tabel berikut merangkum apakah pemeriksaan Penalaran Otomatis berjalan untuk setiap bentuk Converse permintaan. Dalam setiap kasus di mana mereka berjalan, respons model ditambahkan sebagai blok sisi agen (klaim).

Panggilan InvokeModel dengan pemeriksaan Penalaran Otomatis

Cara kerjanya

InvokeModelmembutuhkan dua hal untuk pemeriksaan Penalaran Otomatis:

Format tag XML-nya adalah sebagai berikut:

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

Di mana:

Menandai peran untuk pemeriksaan Penalaran Otomatis

Qualifier hanya menetapkan apakah teks yang diberi tag adalah input sisi pengguna atau sisi agen; Pemeriksaan Penalaran Otomatis memperoleh premis dan klaim saat mereka menerjemahkan input gabungan. Tandai prompt pengguna query untuk memberikan konteks pemeriksaan. Output model secara otomatis ditambahkan sebagai blok sisi agen (klaim), jadi menandai prompt dengan query sendiri sudah cukup untuk menjalankan pemeriksaan.

Multi-tag aturan prioritas dan bersarang

Segmen teks tunggal dapat dibungkus dalam beberapa jenis tag bersarang. Jika beberapa tag diterapkan ke konten yang sama, prioritas menentukan peran Penalaran Otomatis:. guardContent > query > groundingSource Jika konten ditandai dengan keduanya guardContent danquery, itu diperlakukan sebagai klaim.

Aturan bersarang berikut berlaku:

Contoh: Panggilan InvokeModel dengan tag Penalaran Otomatis menggunakan 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

Permintaan ini kembaliautomatedReasoningPolicyUnits: 1, dengan temuan Penalaran Otomatis dalam jejak.

Perilaku default (tanpa tag)

Permintaan yang sama tanpa tag XMLmenggunakan teks biasa:

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

Permintaan ini kembali automatedReasoningPolicyUnits: 0 — Pemeriksaan Penalaran Otomatis tidak berjalan, dan tidak ada kesalahan yang muncul. Pagar pembatas masih mengevaluasi kebijakan lain (konten, topik, kata, dan informasi sensitif), tetapi pemeriksaan Penalaran Otomatis dilewati sepenuhnya.

Menafsirkan temuan Penalaran Otomatis saat runtime

Untuk bertindak berdasarkan temuan Penalaran Otomatis secara terprogram, aplikasi Anda perlu mengekstrak jenis temuan, detail terjemahan, dan aturan pendukung atau kontradiksi. Bagian berikut menjelaskan cara mengurai setiap bagian dari temuan.

Tentukan jenis temuan

Setiap temuan adalah persatuan — persis satu kunci hadir. Periksa kunci mana yang ada untuk menentukan jenis temuan:

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

Baca terjemahannya

Sebagian besar jenis temuan menyertakan translation objek yang menunjukkan bagaimana pemeriksaan Penalaran Otomatis menerjemahkan input bahasa alami ke dalam logika formal. Terjemahannya berisi:

Periksa untranslatedPremises dan untranslatedClaims untuk memahami ruang lingkup validasi. VALIDHasilnya hanya mencakup klaim yang diterjemahkan — konten yang tidak diterjemahkan tidak diverifikasi.

Baca aturan pendukung atau kontradiktif

Bergantung pada jenis temuan, temuan tersebut mencakup aturan yang menjelaskan hasilnya:

Aturan dan skenario ini adalah input utama untuk pola penulisan ulang yang dijelaskan dalam. Tulis ulang tanggapan yang tidak valid menggunakan umpan balik AR

Tentukan hasil agregat

Permintaan validasi tunggal dapat mengembalikan beberapa temuan. Untuk menentukan hasil keseluruhan, urutkan temuan berdasarkan tingkat keparahan dan pilih yang terburuk. Urutan keparahan dari terburuk ke yang terbaik adalah:translationAmbiguous,,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

Menangani hasil validasi dalam aplikasi Anda

Gunakan hasil agregat untuk memutuskan apa yang dilakukan aplikasi Anda selanjutnya. Tabel berikut merangkum tindakan yang disarankan untuk setiap jenis hasil.

Tulis ulang tanggapan yang tidak valid menggunakan umpan balik AR

Pola integrasi yang paling kuat untuk pemeriksaan Penalaran Otomatis adalah loop penulisan ulang: ketika respons invalid atausatisfiable, aplikasi Anda membuat prompt yang mencakup respons asli, temuan spesifik, dan aturan kebijakan, kemudian meminta LLM untuk menulis ulang respons agar konsisten dengan kebijakan. Respons yang ditulis ulang divalidasi lagi, dan loop berlanjut sampai respons valid atau jumlah iterasi maksimum tercapai.

Menulis ulang aliran 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
      

Bangun prompt penulisan ulang

Prompt penulisan ulang harus mencakup tiga informasi dari temuan AR:

Contoh template prompt penulisan ulang:

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.

Menulis ulang praktik terbaik

Ajukan pertanyaan klarifikasi

Ketika Penalaran Otomatis memeriksa kembalitranslationAmbiguous,satisfiable, atau impossible hasil, LLM mungkin tidak memiliki informasi yang cukup untuk menulis ulang respons secara akurat. Dalam kasus ini, aplikasi Anda dapat meminta pengguna untuk klarifikasi, kemudian memasukkan jawaban ke dalam upaya validasi berikutnya.

Kapan harus meminta klarifikasi

Pola klarifikasi

Alur klarifikasi berfungsi sebagai berikut:

Contoh: Hasilkan pertanyaan klarifikasi dari temuan 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.")

Open-source menulis ulang sampel chatbot

Untuk implementasi lengkap gaya produksi dari pola yang dijelaskan di halaman ini, lihat Pemeriksaan Penalaran Otomatis yang menulis ulang chatbot. GitHub Contoh aplikasi ini menunjukkan:

Sampel menggunakan Python/Flask backend dengan frontend React dan berkomunikasi dengan Amazon Bedrock untuk inferensi LLM dan Amazon Bedrock Guardrails untuk validasi melalui API. ApplyGuardrail

Membangun jejak audit

Temuan Penalaran Otomatis memberikan bukti validitas yang dapat diverifikasi secara matematis. Untuk industri yang diatur dan skenario kepatuhan, bukti ini adalah pembeda utama - Anda dapat menunjukkan bahwa respons AI telah diverifikasi terhadap aturan kebijakan tertentu dengan penugasan variabel tertentu, tidak hanya cocok dengan pola atau dinilai secara probabilistik.

Untuk membangun jejak audit yang efektif, catat informasi berikut untuk setiap permintaan validasi:

Contoh: Struktur entri log audit

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