ಲೇಯರ್ಡ್ guard chain ಮೂಲಕ 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 ಪ್ಯಾರಾಮೀಟರ್; ತೂಕದ ಸ್ಕೋರ್ ಇದಕ್ಕಿಂತ ಕಡಿಮೆ ಇರುವ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಅನುಮತಿಸಲಾಗುತ್ತದೆ, ಇದಕ್ಕೆ ಸಮ ಅಥವಾ ಹೆಚ್ಚು ಇರುವವುಗಳನ್ನು ತಡೆಯಲಾಗುತ್ತದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

ಸ್ವತಂತ್ರ ಪದರಗಳು ಒಂದೇ ಗಾರ್ಡ್‌ಗಿಂತ ಏಕೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ

ಯಾವುದೇ ಒಂದೇ ಇಂಜೆಕ್ಷನ್ ಡಿಟೆಕ್ಟರ್ ಉತ್ಪಾದನೆಗೆ ಸಾಕಷ್ಟು ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ. ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚರ್‌ಗಳು ವೇಗವಾಗಿವೆ ಆದರೆ ತಿಳಿದಿರುವ ಸಹಿಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗದ ಹೊಸ ಅಥವಾ ಮರೆಮಾಚಿದ ದಾಳಿಗಳನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳುತ್ತವೆ. 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 ಅನ್ನು ಭಾಗಶಃ-ಫಲಿತಾಂಶದ ಸನ್ನಿವೇಶಗಳನ್ನು ಮನಸ್ಸಿನಲ್ಲಿಟ್ಟುಕೊಂಡು ಆಯ್ಕೆ ಮಾಡಬೇಕು — ಲೇಟೆನ್ಸಿ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸಲು ನಿಧಾನವಾದ, ಹೆಚ್ಚಿನ-ಸಂಕೇತದ ಗಾರ್ಡ್‌ಗಳನ್ನು ಬಿಟ್ಟ ಸಂದರ್ಭಗಳಿಗೆ ಸಂಪ್ರದಾಯವಾದಿ ಮಿತಿಯು ಸರಿದೂಗಿಸುತ್ತದೆ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ಪದರಗಳ ರಕ್ಷಣೆ ಯಾವುದೇ ಒಂದೇ ಗಾರ್ಡ್‌ಗಿಂತ ಏಕೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಈಗ ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿರುವುದರಿಂದ, ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಮತ್ತು ಅದರ ವಿಶ್ವಾಸ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ.

ಗಾರ್ಡ್ ಚೈನ್ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ವಿನ್ಯಾಸ

ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಗಾರ್ಡ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ಆದ್ಯತೆ, ವಿಶ್ವಾಸ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗೆ ತೂಕ ಮತ್ತು ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ಮಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಗಾರ್ಡ್‌ಗಳು ಆದ್ಯತೆಯ ಕ್ರಮದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತವೆ. ಒಂದು ಗಾರ್ಡ್ ತನ್ನ ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ಮಿತಿಗಿಂತ ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸ ಸ್ಕೋರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ, ಸರಪಳಿಯು ನಂತರದ ಗಾರ್ಡ್‌ಗಳನ್ನು ಚಲಾಯಿಸದೆ ತಕ್ಷಣವೇ ವಿನಂತಿಯನ್ನು ತಡೆಯುತ್ತದೆ. ಯಾವುದೇ ಗಾರ್ಡ್ ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ಅನ್ನು ಪ್ರಚೋದಿಸದಿದ್ದರೆ, ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಎಲ್ಲಾ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ ತೂಕದ ವಿಶ್ವಾಸ ಸ್ಕೋರ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತದೆ.

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 ಪೂರ್ಣಾಂಕವನ್ನು ಹೊಂದಿರಬೇಕು, ಇದರಿಂದ run_guard_chain ನಿಧಾನವಾದ LLM-as-judge ಅಥವಾ ಸೆಮ್ಯಾಂಟಿಕ್ ಸ್ಕ್ಯಾನರ್ ಅನ್ನು ಕರೆಯುವ ಮೊದಲೇ ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ನಿರ್ಧಾರವನ್ನು ತಲುಪುತ್ತದೆ, ಮತ್ತು ಬಹುತೇಕ ದುರುದ್ದೇಶಪೂರಿತ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ಒಟ್ಟು ಲೇಟೆನ್ಸಿಯನ್ನು 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 ಗಿಂತ ಕೆಳಗೆ ಇಳಿಸುವ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ.