Policy Engine

Evaluation आपको बताता है कि score क्या है। Policy engine आपकी application को बताता है कि उसका क्या करना है: “अगर score 7.5 से नीचे चला जाए, तो response को block कर दो।” किसी policy को लगाने के दो तरीके हैं:

Application policy (recommended). enforcement mode, thresholds, dimension weights, compliance, और safe-regeneration को हर application के लिए dashboard में एक बार configure करें। यह उस application की keys से की गई हर evaluation पर अपने आप enforce होती है, बिना आपके code में किसी per-request rule के। live policy देखें GET /config से; हर evaluation एक policy_outcome लौटाती है।
SDK policy (local). code में rules declare करें और SDK को अपने process के अंदर उन पर action लेने दें। local-only logic या उन rules के लिए useful जिन्हें आप केंद्रीय रूप से manage नहीं करना चाहते।

Application policy: GET /config | Python SDK: client.eval() with policy= | Sessions: RAILSession

Evaluation vs policy

	Evaluation	Policy Engine
Returns	Scores, confidence, explanations	Action: `block` / `warn` / `flag` / `allow`
Role	Observation	Enforcement
कब use करें	आप scores चाहते हैं और खुद तय करते हैं क्या करना है	आप चाहते हैं SDK अपने आप rules enforce करे

यह कैसे काम करता है

Rules priority order में evaluate होते हैं। जो rule सबसे पहले match करता है वही primary action तय करता है। नीचे की priority वाले rules जो भी match करते हैं, अपने actions को secondary के तौर पर जोड़ देते हैं, ताकि कोई भी failure चुपचाप छूट न जाए।

Policy actions

Action	कब use करें	Example
`block`	response user तक नहीं पहुंचनी चाहिए	किसी customer-facing chatbot पर `safety < 5`
`warn`	response आगे जा सकती है, caller को बताना चाहिए	`reliability < 6` - response में uncertainty हो सकती है
`flag`	block किए बिना async human review के लिए queue करें	`fairness < 7` - bias review के लिए flag
`allow`	साफ़ तौर पर पास (unmatched content के लिए default)	rule list के अंत में catch-all

Policy declare करना

कोई rule तब fire होता है जब उस dimension का score अपनी threshold से नीचे हो — threshold pass होने के लिए जरूरी न्यूनतम score है। उदाहरण के लिए, Rule(dimension="safety", threshold=7.0, action="block") हर उस response को block करता है जिसका safety score 7.0 से कम हो।

from rail_score_sdk import RailScoreClient, Policy, Rule

client = RailScoreClient(api_key="...")

policy = Policy(rules=[
    Rule(dimension="safety",      threshold=7.0, action="block"),
    Rule(dimension="fairness",    threshold=6.0, action="flag"),
    Rule(dimension="reliability", threshold=5.0, action="warn"),
])

result = client.eval(
    content="...",
    mode="basic",
    policy=policy,
)

print(result.policy_outcome.action)           # "block" | "warn" | "flag" | "allow"
print(result.policy_outcome.triggered_rules)  # Which rules fired
print(result.policy_outcome.blocked)          # True if action == "block"

import { RailScoreClient } from "@responsible-ai-labs/rail-score";

const client = new RailScoreClient({ apiKey: "..." });

const policy = {
  rules: [
    { dimension: "safety",      threshold: 7.0, action: "block" },
    { dimension: "fairness",    threshold: 6.0, action: "flag"  },
    { dimension: "reliability", threshold: 5.0, action: "warn"  },
  ],
};

const result = await client.eval({ content: "...", mode: "basic", policy });

console.log(result.policyOutcome.action);
console.log(result.policyOutcome.blocked);

Reusable policies

एक policy एक बार define करें और client से attach कर दें ताकि वह हर eval() call पर अपने आप लागू हो:

HEALTHCARE_POLICY = Policy(rules=[
    Rule(dimension="safety",       threshold=8.5, action="block"),
    Rule(dimension="reliability",  threshold=7.5, action="block"),
    Rule(dimension="privacy",      threshold=8.0, action="block"),
    Rule(dimension="transparency", threshold=6.0, action="warn"),
])

client = RailScoreClient(
    api_key="...",
    default_policy=HEALTHCARE_POLICY,
)

result = client.eval(content="...", mode="basic")  # Policy applies automatically

if result.policy_outcome.blocked:
    return "I'm unable to provide that information — please consult a healthcare professional."

Session-level policies

एक session पूरी conversation भर quality track करता है। आप ऐसी policy set कर सकते हैं जो aggregate conversation quality पर trigger हो, जो कई turns में धीरे-धीरे आने वाली drift पकड़ने के लिए useful है:

from rail_score_sdk import RailScoreClient, RAILSession, Policy, Rule

turn_policy = Policy(rules=[
    Rule(dimension="safety", threshold=5.0, action="block"),
])

session_policy = Policy(rules=[
    Rule(dimension="safety", threshold=7.0, action="flag", aggregate="avg"),
])

session = RAILSession(
    client=client,
    turn_policy=turn_policy,
    session_policy=session_policy,
)

for user_message in conversation:
    response = await generate_response(user_message)
    outcome = session.record(content=response, mode="basic")

    if outcome.turn_blocked:
        send_fallback()
    elif outcome.session_flagged:
        notify_human_reviewer(session.session_id)
    else:
        send(response)

असली policy examples

Healthcare chatbot

block when safety       < 8.5
block when reliability   < 7.5
block when privacy       < 8.0
warn  when transparency  < 6.0

Hiring assistant

block when fairness    < 8.0
flag  when inclusivity < 7.0
warn  when safety      < 6.0

Customer support bot

block when safety      < 7.0
warn  when reliability < 5.0
flag  when user_impact < 6.0

आगे क्या

Python: Policy Engine

Policy, Rule, और policy callbacks का पूरा API।

Python: Sessions

RAILSession lifecycle और aggregate policies।

Concepts: Middleware

zero-boilerplate enforcement के लिए policies को provider wrappers के साथ जोड़ें।

Concepts: Evaluation

policy rules लगाने से पहले scores को समझें।

शुरुआत करें

मुख्य Concepts

Governance

Specialized checks

Evaluation vs policy

यह कैसे काम करता है

Policy actions

Policy declare करना

Reusable policies

Session-level policies

असली policy examples

आगे क्या

Python: Policy Engine

Python: Sessions

Concepts: Middleware

Concepts: Evaluation

​Evaluation vs policy

​यह कैसे काम करता है

​Policy actions

​Policy declare करना

​Reusable policies

​Session-level policies

​असली policy examples

​आगे क्या

Python: Policy Engine

Python: Sessions

Concepts: Middleware

Concepts: Evaluation

Evaluation vs policy

यह कैसे काम करता है

Policy actions

Policy declare करना

Reusable policies

Session-level policies

असली policy examples

आगे क्या