Zum Hauptinhalt springen
Die Bewertung sagt Ihnen, wie hoch der Score ist. Die Richtlinien-Engine sagt Ihrer Anwendung, was damit zu tun ist: “Wenn der Score unter 7,5 fällt, blockiere die Antwort.” Es gibt zwei Wege, eine Richtlinie anzuwenden:
  • Anwendungsrichtlinie (empfohlen). Konfigurieren Sie Durchsetzungsmodus, Schwellenwerte, Dimensionsgewichtungen, Compliance und sichere Regeneration einmalig pro Anwendung im Dashboard. Sie wird automatisch für jede Bewertung durchgesetzt, die mit den Schlüsseln dieser Anwendung erfolgt, ohne Regeln pro Anfrage in Ihrem Code. Prüfen Sie die aktive Richtlinie mit GET /config; jede Bewertung meldet ein policy_outcome.
  • SDK-Richtlinie (lokal). Deklarieren Sie Regeln im Code und lassen Sie das SDK in Ihrem Prozess danach handeln. Nützlich für rein lokale Logik oder Regeln, die Sie nicht zentral verwalten möchten.
Anwendungsrichtlinie: GET /config | Python SDK: client.eval() mit policy= | Sessions: RAILSession

​
Bewertung vs. Richtlinie

BewertungRichtlinien-Engine
Gibt zurückScores, Konfidenz, ErklärungenAktion: block / warn / flag / allow
RolleBeobachtungDurchsetzung
Wann verwendenSie möchten Scores und entscheiden selbstSie möchten, dass das SDK Regeln automatisch durchsetzt

​
Funktionsweise

Regeln werden in der Reihenfolge ihrer Priorität ausgewertet. Die erste zutreffende Regel bestimmt die primäre Aktion. Regeln mit niedrigerer Priorität, die ebenfalls zutreffen, hängen ihre Aktionen als sekundär an, sodass kein Fehler stillschweigend übergangen wird.

​
Richtlinien-Aktionen

AktionWann verwendenBeispiel
blockAntwort darf den Nutzer nicht erreichensafety < 5 bei einem kundenseitigen Chatbot
warnAntwort darf weitergehen, der Aufrufer sollte benachrichtigt werdenreliability < 6 - Antwort enthält möglicherweise Unsicherheit
flagFür asynchrone menschliche Prüfung in die Warteschlange, ohne zu blockierenfairness < 7 - zur Vorurteilsprüfung kennzeichnen
allowExplizit durchlassen (Standard für nicht zutreffende Inhalte)Auffangregel am Ende einer Regelliste

​
Eine Richtlinie deklarieren

Eine Regel greift, wenn die betreffende Dimension unter ihrem threshold bewertet wird — threshold ist das Minimum, das zum Bestehen nötig ist. Zum Beispiel blockiert Rule(dimension="safety", threshold=7.0, action="block") jede Antwort, deren Safety-Score unter 7,0 liegt. 
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"

​
Wiederverwendbare Richtlinien

Definieren Sie eine Richtlinie einmal und hängen Sie sie an den Client an, sodass sie automatisch auf jeden eval()-Aufruf angewendet wird: 
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."

​
Richtlinien auf Session-Ebene

Eine Session verfolgt die Qualität über eine gesamte Konversation. Sie können eine Richtlinie festlegen, die auf die aggregierte Konversationsqualität reagiert, was nützlich ist, um allmähliche Abweichungen über viele Gesprächsrunden hinweg zu erkennen: 
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)

​
Praxisbeispiele für Richtlinien

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

​
Wie geht es weiter

Python: Richtlinien-Engine

Vollständige API für Policy, Rule und Richtlinien-Callbacks.

Python: Sessions

RAILSession-Lebenszyklus und aggregierte Richtlinien.

Konzepte: Middleware

Richtlinien mit Anbieter-Wrappern für Durchsetzung ohne Boilerplate kombinieren.

Konzepte: Bewertung

Scores verstehen, bevor Sie Richtlinienregeln anwenden.