Passer au contenu principal
L’évaluation vous indique quel est le score. Le moteur de politiques indique à votre application ce qu’il faut en faire : « si le score descend en dessous de 7,5, bloquer la réponse ». Il existe deux manières d’appliquer une politique :
  • Politique d’application (recommandée). Configurez une fois le mode d’application, les seuils, les pondérations de dimensions, la conformité et la régénération sécurisée par application dans le tableau de bord. Elle est appliquée automatiquement à chaque évaluation effectuée avec les clés de cette application, sans aucune règle par requête dans votre code. Inspectez la politique en vigueur avec GET /config ; chaque évaluation rapporte un policy_outcome.
  • Politique SDK (locale). Déclarez des règles dans le code et laissez le SDK agir dessus dans votre processus. Utile pour une logique purement locale ou des règles que vous ne souhaitez pas gérer de manière centralisée.
Politique d’application : GET /config | SDK Python : client.eval() avec policy= | Sessions : RAILSession

​
Évaluation vs politique

ÉvaluationMoteur de politiques
RetourneScores, confiance, explicationsAction : block / warn / flag / allow
RôleObservationApplication
Quand l’utiliserVous voulez les scores et décidez quoi en faireVous voulez que le SDK applique les règles automatiquement

​
Comment ça fonctionne

Les règles sont évaluées par ordre de priorité. La première règle déclenchée détermine l’action principale. Les règles de priorité inférieure qui sont aussi déclenchées ajoutent leurs actions en secondaire, de sorte qu’aucun problème n’est silencieusement ignoré.

​
Actions de politique

ActionQuand l’utiliserExemple
blockLa réponse ne doit pas atteindre l’utilisateursafety < 5 sur un chatbot orienté client
warnLa réponse peut être transmise, l’appelant doit être notifiéreliability < 6 - la réponse peut contenir de l’incertitude
flagMettre en file d’attente pour une revue humaine asynchrone sans bloquerfairness < 7 - signaler pour revue de biais
allowLaisser passer explicitement (par défaut pour le contenu non couvert)Règle de rattrapage en fin de liste

​
Déclarer une politique

Une règle se déclenche lorsque la dimension obtient un score inférieur à son threshold — le threshold est le minimum requis pour passer. Par exemple, Rule(dimension="safety", threshold=7.0, action="block") bloque toute réponse dont le score de sécurité est inférieur à 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"

​
Politiques réutilisables

Définissez une politique une seule fois et attachez-la au client pour qu’elle s’applique automatiquement à chaque appel eval() : 
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."

​
Politiques au niveau de la session

Une session suit la qualité sur l’ensemble d’une conversation. Vous pouvez définir une politique qui se déclenche sur la qualité agrégée de la conversation, ce qui est utile pour détecter une dégradation progressive sur de nombreux échanges : 
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)

​
Exemples de politiques concrets

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

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

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

​
Et ensuite

Python : Moteur de politiques

API complète pour Policy, Rule et les callbacks de politique.

Python : Sessions

Cycle de vie de RAILSession et politiques agrégées.

Concepts : Middleware

Combinez les politiques avec les wrappers de fournisseurs pour une application sans boilerplate.

Concepts : Évaluation

Comprendre les scores avant d’appliquer des règles de politique.