లేయర్డ్ గార్డ్ చెయిన్‌తో defense-in-depth నిర్మించండి

పరిచయం

ప్రొడక్షన్‌లో మీరు ఒకే ఒక ఇంజెక్షన్ డిటెక్టర్‌పై ఆధారపడినప్పుడు, ఒక్క తప్పిపోయిన ప్యాటర్న్ లేదా ఒక్క అడ్వర్సేరియల్ బైపాస్ మీ మొత్తం రక్షణను ఓడిస్తుంది. Lethal Trifecta ఫ్రేమ్‌వర్క్ దీన్ని పరిష్కరిస్తుంది — ప్యాటర్న్ మ్యాచర్లు, LLM-as-judge క్లాసిఫైయర్లు, మరియు సెమాంటిక్ స్కానర్లు అనే బహుళ స్వతంత్ర గార్డ్‌లను ఒక పైప్‌లైన్‌లో గొలుసుగా కలుపుతుంది, ఇక్కడ ప్రతి పొర మిగతా పొరల బ్లైండ్ స్పాట్‌లను భర్తీ చేస్తుంది. ఈ పాఠం ముగిసేసరికి, షార్ట్-సర్క్యూట్ లాజిక్, ప్రతి-గార్డ్ కాన్ఫిడెన్స్ వెయిటింగ్, మరియు లేటెన్సీ బడ్జెట్ నిర్వహణతో కూడిన గార్డ్ చెయిన్ ఆర్కెస్ట్రేటర్‌ను మీరు అమలు చేయగలుగుతారు, ఇది డైరెక్ట్ మరియు ఇన్‌డైరెక్ట్ దాడి మార్గాలలో ప్రాంప్ట్ ఇంజెక్షన్ ప్రయత్నాలను నిరోధిస్తుంది.

కీలక పదజాలం

• Lethal Trifecta — మూడు తరగతుల స్వతంత్ర గార్డ్‌లను — ప్యాటర్న్ మ్యాచర్లు, LLM-as-judge క్లాసిఫైయర్లు, మరియు సెమాంటిక్ స్కానర్లు — గొలుసుగా కలిపే డిఫెన్స్-ఇన్-డెప్త్ ఫ్రేమ్‌వర్క్, దీనిలో ప్రతి పొర యొక్క కవరేజ్ మిగతా పొరల బ్లైండ్ స్పాట్‌లను భర్తీ చేస్తుంది.
• Guard Priority (గార్డ్ ప్రాధాన్యత) — GuardConfigలోని ఒక సంఖ్యా ఫీల్డ్ (తక్కువ విలువ = అధిక ప్రాధాన్యత), ఇది చెయిన్‌లో అమలు క్రమాన్ని నిర్ణయిస్తుంది, LLM-as-judge లాంటి లేటెన్సీ-భారమైన డిటెక్టర్ల కంటే ముందు చవకైన వేగవంతమైన డిటెక్టర్లు నడిచేలా చూస్తుంది.
• Short-Circuit Threshold (షార్ట్-సర్క్యూట్ థ్రెషోల్డ్) — GuardConfigలోని ప్రతి-గార్డ్ short_circuit_threshold విలువ; ఒక గార్డ్ తిరిగి ఇచ్చిన కాన్ఫిడెన్స్ దీన్ని చేరినప్పుడు లేదా దాటినప్పుడు, run_guard_chain మిగిలిన గార్డ్‌లలో ఏదీ ఇన్వోక్ చేయకుండా వెంటనే allowed=False తిరిగి ఇస్తుంది.
• Latency Budget (లేటెన్సీ బడ్జెట్) — run_guard_chainకు పాస్ చేసే budget_ms గరిష్ట పరిమితి; గడిచిన సమయం మరియు ఒక గార్డ్ యొక్క timeout_ms కలిపి ఈ విలువను దాటితే, ఆర్కెస్ట్రేటర్ ఆ గార్డ్‌ను దాటవేసి, ఇప్పటివరకు సేకరించిన ఫలితాలపై అగ్రిగేషన్‌కు కొనసాగుతుంది.
• Weighted Confidence Aggregation (వెయిటెడ్ కాన్ఫిడెన్స్ అగ్రిగేషన్) — పూర్తయిన అన్ని GuardResult స్కోర్‌లపై aggregate_confidence గణించే నార్మలైజ్డ్ వెయిటెడ్ సగటు, ఇక్కడ ప్రతి గార్డ్ యొక్క కాంట్రిబ్యూషన్ GuardConfigలోని దాని weight ద్వారా స్కేల్ చేయబడుతుంది, గార్డ్ రకాల మధ్య భిన్నమైన నమ్మకాన్ని వ్యక్తపరుస్తుంది.
• Chain Threshold (చెయిన్ థ్రెషోల్డ్) — తుది అగ్రిగేటెడ్ కాన్ఫిడెన్స్ స్కోర్‌తో పోల్చే chain_threshold పారామీటర్; వెయిటెడ్ స్కోర్ దీని కంటే తక్కువగా ఉన్న ఇన్‌పుట్‌లు అనుమతించబడతాయి, దీనికి సమానంగా లేదా ఎక్కువగా ఉన్నవి నిరోధించబడతాయి.

భావనలు

ఒకే గార్డ్ కంటే స్వతంత్ర పొరలు ఎందుకు మెరుగ్గా పనిచేస్తాయి

ప్రొడక్షన్‌కు సరిపడేంత నమ్మకమైన ఒకే ఇంజెక్షన్ డిటెక్టర్ ఏదీ లేదు. ప్యాటర్న్ మ్యాచర్లు వేగవంతమైనవి కానీ తెలిసిన సిగ్నేచర్‌లకు సరిపోలని కొత్త లేదా అస్పష్టీకరించిన (obfuscated) దాడులను తప్పిపోతాయి. LLM-as-judge క్లాసిఫైయర్లు మెరుగ్గా సాధారణీకరిస్తాయి కానీ పదుల నుంచి వందల మిల్లీసెకన్ల లేటెన్సీని జోడిస్తాయి, మరియు ఒక భాషా మోడల్‌ను గందరగోళపరిచేలా రూపొందించిన అడ్వర్సేరియల్ ఇన్‌పుట్‌ల ద్వారా అవే తప్పుదోవ పట్టవచ్చు. సెమాంటిక్ స్కానర్లు ప్యాటర్న్ రూల్స్ ఎప్పటికీ వ్యక్తపరచలేని ఎంబెడ్డింగ్-స్పేస్ అసాధారణతలను పట్టుకుంటాయి, కానీ వాటి కచ్చితత్వం రిఫరెన్స్ కార్పస్ మీ థ్రెట్ సర్ఫేస్‌ను ఎంత బాగా కవర్ చేస్తుందనే దానిపై ఆధారపడుతుంది. ప్రతి డిటెక్టర్‌కు ఒక ప్రత్యేకమైన వైఫల్య రీతి ఉంటుంది — మరియు మీ సిస్టమ్‌ను అధ్యయనం చేసే దాడిదారుడు, అది మీ ఏకైక పొర అయితే, బలహీనమైన పొరను మాత్రమే ఓడించాల్సి ఉంటుంది.

Lethal Trifecta ఫ్రేమ్‌వర్క్ స్వతంత్ర వైఫల్య రీతులను రక్షణ యొక్క నిర్మాణాత్మక ప్రయోజనంగా మార్చుతుంది. భిన్నమైన పద్ధతులు కలిగిన మూడు డిటెక్టర్లలో ప్రతిదానికీ ఒక దాడిని తప్పిపోయే కొంత సంభావ్యత ఉన్నప్పుడు, మూడూ ఒకే దాడిని తప్పిపోయే సంభావ్యత వాటి వ్యక్తిగత మిస్ రేట్ల లబ్ధం — ఏ ఒక్క డిటెక్టర్ కంటే చాలా తక్కువ. గార్డ్ చెయిన్ ఆర్కిటెక్చర్ (కోడ్ వాక్‌త్రూ చూడండి) ఈ స్వతంత్ర గార్డ్‌లను కలిపి వైర్ చేయడానికి ఆర్కెస్ట్రేషన్ యంత్రాంగాన్ని అందిస్తుంది, అదే సమయంలో లేటెన్సీని ఊహించదగినదిగా ఉంచుతూ, ప్రతి గార్డ్ తీర్పును బృందం క్యాలిబ్రేట్ చేసిన నమ్మకం ప్రకారం వెయిట్ చేస్తుంది.

గార్డ్ క్రమం మరియు షార్ట్-సర్క్యూట్ లాజిక్

మూల్యాంకనం ప్రారంభం కావడానికి ముందు ఆర్కెస్ట్రేటర్ గార్డ్‌లను వాటి priority ఫీల్డ్ ప్రకారం క్రమబద్ధీకరిస్తుంది. డిజైన్ సూత్రం వ్యయ అసమానత: 1 ms లోపు పూర్తయ్యే ప్యాటర్న్ మ్యాచర్, LLM కాల్ వ్యయంలో అతి చిన్న భాగంతో తెలిసిన ఇంజెక్షన్ స్ట్రింగ్‌ను ఖచ్చితంగా నిరోధించగలదు. చవకైన, అత్యంత నిర్ణయాత్మకమైన గార్డ్‌లను ముందు ఉంచడం అంటే, ఖరీదైన దిగువ పొరలను చేరడానికి ముందే స్పష్టమైన దాడులు ఆపబడతాయి.

షార్ట్-సర్క్యూట్ లాజిక్ దీన్ని అధికారికంగా రూపొందిస్తుంది. ప్రతి GuardConfig దాని సొంత short_circuit_thresholdను కలిగి ఉంటుంది. ఒక గార్డ్ ఆ విలువకు సమానమైన లేదా ఎక్కువ కాన్ఫిడెన్స్ స్కోర్‌ను తిరిగి ఇచ్చిన క్షణంలో, run_guard_chain short_circuited=Trueగా సెట్ చేసి allowed=False తిరిగి ఇస్తుంది — క్రమబద్ధీకరించిన జాబితాలో మిగిలిన గార్డ్‌లు ఎప్పుడూ అమలు కావు. తక్కువ కాన్ఫిడెన్స్‌తో వేగవంతమైన డిటెక్టర్లను దాటిన ఇన్‌పుట్‌లు మాత్రమే పూర్తి చెయిన్ ద్వారా అగ్రిగేషన్ వరకు కొనసాగుతాయి.

కాన్ఫిడెన్స్ వెయిటింగ్ మరియు తుది నిర్ణయం

ఏ గార్డ్ షార్ట్-సర్క్యూట్‌ను ట్రిగ్గర్ చేయనప్పుడు, పూర్తయిన అన్ని GuardResult ఆబ్జెక్ట్‌లు aggregate_confidenceకు పాస్ చేయబడతాయి. ప్రతి ఫలితం యొక్క కాన్ఫిడెన్స్ స్కోర్ దాని గార్డ్ యొక్క weightతో గుణించబడుతుంది — ఇది GuardConfigలో సెట్ చేసిన విలువ, క్యాలిబ్రేట్ చేసిన నమ్మకాన్ని ఎన్‌కోడ్ చేస్తుంది. పూర్తిగా పరీక్షించిన ప్యాటర్న్ గార్డ్‌కు 0.3 వెయిట్, క్యాలిబ్రేట్ చేసిన LLM-as-judgeకు 0.5, మరియు కొత్త ప్రయోగాత్మక డిటెక్టర్‌కు 0.2 ఉండవచ్చు. సేకరించిన వెయిటెడ్ మొత్తాన్ని మొత్తం వెయిట్‌తో భాగించడం ద్వారా, ఎన్ని గార్డ్‌లు పూర్తయినా సరే 0.0 మరియు 1.0 మధ్య నార్మలైజ్డ్ స్కోర్ వస్తుంది.

ఆ స్కోర్‌ను ఆ తర్వాత chain_thresholdతో పోల్చుతారు. లేటెన్సీ బడ్జెట్ ఈ దశతో ఒక ముఖ్యమైన విధంగా పరస్పర చర్య చేస్తుంది: అన్ని గార్డ్‌లు నడవడానికి ముందే బడ్జెట్ ముగిసిపోతే, పూర్తయిన గార్డ్‌లపై మాత్రమే అగ్రిగేషన్ కొనసాగుతుంది. అంటే chain_thresholdను పాక్షిక-ఫలిత సన్నివేశాలను దృష్టిలో ఉంచుకొని ఎంచుకోవాలి — లేటెన్సీ అవసరాలను తీర్చడానికి నెమ్మదైన, అధిక-సిగ్నల్ గార్డ్‌లు దాటవేయబడిన సందర్భాలను సంప్రదాయవాద (conservative) థ్రెషోల్డ్ భర్తీ చేస్తుంది.

కోడ్ వాక్‌త్రూ

ఏ ఒక్క గార్డ్ కంటే పొరలవారీ రక్షణ ఎందుకు మెరుగ్గా పనిచేస్తుందో ఇప్పుడు మీకు అర్థమైంది, ఇక ఆర్కెస్ట్రేటర్ మరియు దాని కాన్ఫిడెన్స్ అగ్రిగేషన్ కోడ్‌లో ఎలా అమలు చేయబడ్డాయో ఇక్కడ చూద్దాం.

గార్డ్ చెయిన్ ఆర్కెస్ట్రేటర్ డిజైన్

ఆర్కెస్ట్రేటర్ గార్డ్‌ల జాబితాను నిర్వహిస్తుంది, ప్రతిదానికీ ఒక ప్రాధాన్యత, కాన్ఫిడెన్స్ అగ్రిగేషన్ కోసం ఒక వెయిట్, మరియు ఒక షార్ట్-సర్క్యూట్ థ్రెషోల్డ్ ఉంటాయి. గార్డ్‌లు ప్రాధాన్యత క్రమంలో అమలు అవుతాయి. ఒక గార్డ్ దాని షార్ట్-సర్క్యూట్ థ్రెషోల్డ్ కంటే ఎక్కువ కాన్ఫిడెన్స్ స్కోర్‌ను తిరిగి ఇస్తే, తర్వాతి గార్డ్‌లను నడపకుండా చెయిన్ వెంటనే అభ్యర్థనను నిరోధిస్తుంది. ఏ గార్డ్ షార్ట్-సర్క్యూట్‌ను ట్రిగ్గర్ చేయకపోతే, ఆర్కెస్ట్రేటర్ అన్ని ఫలితాలను సేకరించి వెయిటెడ్ కాన్ఫిడెన్స్ స్కోర్‌ను గణిస్తుంది.

Code snippetpython
1from __future__ import annotations
2from typing import Optional
3from pydantic import BaseModel, Field
4
5class GuardConfig(BaseModel):
6    guard_id: str
7    guard_type: str  # "pattern", "llm_judge", "guardrails", "document_scanner"
8    priority: int = Field(ge=0, description="Lower number = higher priority")
9    weight: float = Field(ge=0.0, le=1.0)
10    short_circuit_threshold: float = Field(ge=0.0, le=1.0)
11    timeout_ms: int = Field(default=1000)
12    enabled: bool = True
13
14class GuardResult(BaseModel):
15    guard_id: str
16    confidence: float
17    triggered: bool
18    latency_ms: float
19
20class GuardChainResult(BaseModel):
21    allowed: bool
22    total_confidence: float
23    guard_results: list[GuardResult]
24    short_circuited: bool = False
25    short_circuit_guard: Optional[str] = None
26    total_latency_ms: float
27
28def aggregate_confidence(
29    guard_results: list[GuardResult],
30    guard_configs: dict[str, GuardConfig],
31) -> float:
32    weighted_sum = 0.0
33    total_weight = 0.0
34    for result in guard_results:
35        config = guard_configs[result.guard_id]
36        weighted_sum += result.confidence * config.weight
37        total_weight += config.weight
38    return weighted_sum / total_weight if total_weight > 0 else 0.0

ఒక గార్డ్‌ను షెడ్యూల్ చేయడానికి ఆర్కెస్ట్రేటర్‌కు అవసరమైన ప్రతిదాన్ని GuardConfig పట్టుకుంటుంది: దాని అమలు ప్రాధాన్యత, అగ్రిగేషన్ సమయంలో దాని కాన్ఫిడెన్స్ స్కోర్‌కు వర్తించే వెయిట్, తక్షణ నిరోధాన్ని ట్రిగ్గర్ చేసే షార్ట్-సర్క్యూట్ థ్రెషోల్డ్, మరియు నెమ్మదైన డిటెక్టర్ పైప్‌లైన్‌ను అనిర్దిష్టంగా నిలిపివేయకుండా ఉండేందుకు ప్రతి-గార్డ్ టైమ్‌అవుట్.

aggregate_confidence వెయిటెడ్ సగటు దశను అమలు చేస్తుంది. ఇది పూర్తయిన ప్రతి GuardResultపై ఇటరేట్ చేస్తుంది, guard_configs డిక్షనరీ నుంచి ఆ గార్డ్ యొక్క weightను చూస్తుంది, మరియు weighted_sum మరియు total_weightను సేకరిస్తుంది. చివరిలో భాగించడం ద్వారా 0.0 మరియు 1.0 మధ్య నార్మలైజ్డ్ స్కోర్ వస్తుంది. ఇదే Lethal Trifecta ఫ్రేమ్‌వర్క్ భిన్నమైన నమ్మకాన్ని వ్యక్తపరచడానికి అనుమతిస్తుంది — పూర్తిగా పరీక్షించిన ప్యాటర్న్ గార్డ్‌కు 0.3 వెయిట్, క్యాలిబ్రేట్ చేసిన LLM-as-judgeకు 0.5, మరియు కొత్త ప్రయోగాత్మక డిటెక్టర్‌కు 0.2 ఉండవచ్చు, తద్వారా చెయిన్ యొక్క తుది నిర్ణయం ప్రతి పొరపై బృందం యొక్క నమ్మకాన్ని ప్రతిబింబిస్తుంది.

లేటెన్సీ బడ్జెట్ నిర్వహణ

గార్డ్ చెయిన్ పూర్తి మూల్యాంకన పైప్‌లైన్ కోసం మొత్తం లేటెన్సీ బడ్జెట్‌ను అమలు చేస్తుంది. తర్వాతి గార్డ్‌ను నడపడానికి మిగిలిన బడ్జెట్ సరిపోకపోతే, ఆర్కెస్ట్రేటర్ దాన్ని దాటవేసి, ఇప్పటికే పూర్తయిన గార్డ్‌ల ఆధారంగా నిర్ణయం తీసుకుంటుంది. ఇది లేటెన్సీ-సున్నితమైన ఎండ్‌పాయింట్‌లలో సెక్యూరిటీ పైప్‌లైన్ అడ్డంకిగా మారకుండా నివారిస్తుంది.

Code snippetpython
1import time
2
3def run_guard_chain(
4    user_input: str,
5    guards: list[tuple[GuardConfig, callable]],
6    chain_threshold: float,
7    budget_ms: float,
8) -> GuardChainResult:
9    guard_configs = {cfg.guard_id: cfg for cfg, _ in guards}
10    results: list[GuardResult] = []
11    start = time.monotonic()
12
13    for config, evaluate in sorted(guards, key=lambda g: g[0].priority):
14        if not config.enabled:
15            continue
16        elapsed_ms = (time.monotonic() - start) * 1000
17        if elapsed_ms + config.timeout_ms > budget_ms:
18            break  # skip remaining guards to respect latency budget
19
20        t0 = time.monotonic()
21        confidence = evaluate(user_input)
22        latency = (time.monotonic() - t0) * 1000
23
24        result = GuardResult(
25            guard_id=config.guard_id,
26            confidence=confidence,
27            triggered=confidence >= config.short_circuit_threshold,
28            latency_ms=latency,
29        )
30        results.append(result)
31
32        if result.triggered:
33            return GuardChainResult(
34                allowed=False,
35                total_confidence=confidence,
36                guard_results=results,
37                short_circuited=True,
38                short_circuit_guard=config.guard_id,
39                total_latency_ms=(time.monotonic() - start) * 1000,
40            )
41
42    total_confidence = aggregate_confidence(results, guard_configs)
43    return GuardChainResult(
44        allowed=total_confidence < chain_threshold,
45        total_confidence=total_confidence,
46        guard_results=results,
47        total_latency_ms=(time.monotonic() - start) * 1000,
48    )

గార్డ్‌లు priority ప్రకారం క్రమబద్ధీకరించబడతాయి, తద్వారా చవకైన, వేగవంతమైన డిటెక్టర్లు — సాధారణంగా 1 ms లోపు పూర్తయ్యే ప్యాటర్న్ మ్యాచర్లు — ముందుగా నడుస్తాయి. అధిక-కాన్ఫిడెన్స్ హిట్ వెంటనే షార్ట్-సర్క్యూట్ చేస్తుంది, LLM-as-judge లేదా సెమాంటిక్ స్కానర్ పొరల లేటెన్సీని పూర్తిగా తప్పిస్తుంది. అస్పష్టమైన ఇన్‌పుట్‌లు మాత్రమే పూర్తి చెయిన్ ద్వారా కొనసాగి, chain_thresholdకు వ్యతిరేకంగా వెయిటెడ్ నిర్ణయం కోసం aggregate_confidenceకు చేరుతాయి.

తెలిసిన ఇంజెక్షన్ స్ట్రింగ్‌తో run_guard_chainను కాల్ చేసినప్పుడు, ప్యాటర్న్ గార్డ్ ఫైర్ అయితే తిరిగి వచ్చిన GuardChainResult.allowed Falseగా మరియు short_circuited Trueగా ఉందని, మరియు చెయిన్‌లో ముందుగానే పట్టుబడిన ఇన్‌పుట్‌లకు total_latency_ms కాన్ఫిగర్ చేసిన budget_ms కంటే బాగా తక్కువగా ఉంటుందని నిర్ధారించుకోండి.

డిసిప్లిన్ అనువర్తనం

చేయవలసినవి మరియు చేయకూడనివి

ఇప్పుడు మీరు అమలును పూర్తిగా చూశారు, దిగువ పద్ధతులు మన్నికైన విధానాన్ని బలహీనమైన విధానం నుంచి వేరు చేస్తాయి.

చేయవలసినవి

1. వేగవంతమైన డిటెక్టర్లు ముందుగా నడిచేలా గార్డ్‌లకు ప్రాధాన్యత విలువలను కేటాయించండి — 1 ms లోపు పూర్తయ్యే ప్యాటర్న్ మ్యాచర్లు GuardConfigలో అతి తక్కువ priority పూర్ణాంకాన్ని కలిగి ఉండాలి, తద్వారా నెమ్మదైన LLM-as-judge లేదా సెమాంటిక్ స్కానర్‌ను ఇన్వోక్ చేయడానికి ముందే run_guard_chain షార్ట్-సర్క్యూట్ నిర్ణయానికి చేరుతుంది, మెజారిటీ హానికర ఇన్‌పుట్‌లకు మొత్తం లేటెన్సీని budget_ms కంటే బాగా తక్కువగా ఉంచుతుంది.
2. ఆ డిటెక్టర్‌పై మీ బృందం క్యాలిబ్రేట్ చేసిన నమ్మకాన్ని ప్రతిబింబించేలా GuardConfigలో ప్రతి గార్డ్ యొక్క weightను ట్యూన్ చేయండి — aggregate_confidence వెయిటెడ్ సగటును ఉత్పత్తి చేస్తుంది, తద్వారా weight=0.5 వద్ద పూర్తిగా ధృవీకరించిన LLM-as-judge weight=0.2 వద్ద ఉన్న కొత్త ప్రయోగాత్మక డిటెక్టర్‌పై సరిగ్గా ఆధిపత్యం చెలాయిస్తుంది, మరియు chain_thresholdకు వ్యతిరేకంగా చెయిన్ యొక్క తుది నిర్ణయం అమాయక మెజారిటీ ఓటు కాకుండా వాస్తవ భిన్నమైన కాన్ఫిడెన్స్‌ను సూచిస్తుంది.
3. ప్రతి గార్డ్‌కు timeout_ms సెట్ చేసి, run_guard_chainలో మొత్తం budget_msను అమలు చేయండి — timeout_ms elapsed_msను budget_ms దాటేలా చేసే ఏ గార్డ్‌ను ఆర్కెస్ట్రేటర్ దాటవేస్తుంది, LLM-as-judge కాల్ నెమ్మదిగా ఉన్నప్పుడు కూడా ప్రొడక్షన్ ఎండ్‌పాయింట్‌లలో సెక్యూరిటీ పైప్‌లైన్ ఎప్పుడూ లేటెన్సీ అడ్డంకిగా మారకుండా చూస్తుంది.

చేయకూడనివి

1. ఒకే గార్డ్‌పై ఆధారపడి దాన్ని డిఫెన్స్-ఇన్-డెప్త్ అని పిలవకండి — ప్యాటర్న్ మ్యాచర్ మీ ఏకైక పొర అయితే, ఒక అడ్వర్సేరియల్ బైపాస్ (కొత్త ఎన్‌కోడింగ్ లేదా రిట్రీవ్ చేసిన డాక్యుమెంట్ ద్వారా ఇన్‌డైరెక్ట్ ఇంజెక్షన్) మరే తనిఖీ లేకుండా allowed=True తిరిగి ఇస్తుంది; ప్రతి గార్డ్ రకానికి మిగతావి భర్తీ చేసే ప్రత్యేక బ్లైండ్ స్పాట్‌లు ఉండడం వల్లే Lethal Trifecta చెయిన్ ఉనికిలో ఉంది.
2. మీ డిటెక్టర్లకు అర్థవంతంగా భిన్నమైన ప్రెసిషన్ ఉన్నప్పుడు అన్ని గార్డ్ weight విలువలను సమానంగా సెట్ చేయకండి — సమాన వెయిట్‌లు aggregate_confidenceకు ఫ్లాట్ సగటును అందిస్తాయి, మీ అత్యంత నమ్మకమైన క్లాసిఫైయర్ నుంచి వచ్చే సిగ్నల్‌ను తుడిచివేస్తాయి, మరియు అధిక-కాన్ఫిడెన్స్ LLM-as-judge ఫలితాన్ని సరిగ్గా క్యాలిబ్రేట్ చేయని ప్రయోగాత్మక డిటెక్టర్ chain_threshold కంటే దిగువకు పలుచన చేసేందుకు అనుమతిస్తాయి.
3. ప్రాధాన్యత లూప్ లోపల short_circuit_threshold తనిఖీని వదిలివేయకండి — run_guard_chainలో ముందస్తు-return శాఖను దాటవేయడం, స్పష్టమైన ఇంజెక్షన్‌లతో సహా ప్రతి ఇన్‌పుట్‌ను పూర్తి చెయిన్ ద్వారా aggregate_confidenceలోకి బలవంతంగా పంపుతుంది, అనవసర లేటెన్సీని జోడిస్తుంది, మరియు మొదటి గార్డ్‌కు నిరోధించడానికి ఇప్పటికే నిర్ణయాత్మక సాక్ష్యం ఉన్నప్పుడు తర్వాతి గార్డ్‌లకు వెయిటెడ్ స్కోర్‌ను chain_threshold కంటే దిగువకు తగ్గించే అవకాశం ఇస్తుంది.