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.

Ikhtisar integrasi

Saat runtime, integrasi mengikuti alur ini:

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
    

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

Halaman ini berfokus pada ApplyGuardrail API karena memberikan fleksibilitas paling besar untuk menerapkan pola penulisan ulang dan klarifikasi yang dijelaskan di bawah ini. Untuk informasi tentang menggunakan pagar pembatas dengan yang lain APIs, lihat Menggunakan pagar pembatas.

Contoh chatbot penulisan ulang sumber terbuka

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

Panggilan ApplyGuardrail dengan pemeriksaan Penalaran Otomatis

Gunakan ApplyGuardrail API untuk memvalidasi konten terhadap pagar pembatas Anda. API menerima satu atau beberapa blok konten dan mengembalikan penilaian yang mencakup temuan Penalaran Otomatis.

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, lihatHasil temuan dan validasi.

Menafsirkan temuan AR 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: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

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

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
}