> ## Documentation Index
> Fetch the complete documentation index at: https://docs.responsibleailabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Richtlinien-Engine

> Deklarative Regeln, die RAIL-Scores in Aktionen übersetzen: blockieren, warnen, kennzeichnen oder erlauben.

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](/concepts/applications) 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`](/api-reference/config); jede Bewertung meldet ein [`policy_outcome`](/api-reference/evaluation).
* **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.

<Info>
  **Anwendungsrichtlinie:** [`GET /config`](/api-reference/config) | **Python SDK:** [`client.eval()` mit `policy=`](/sdk/python/policy-engine) | **Sessions:** [RAILSession](/sdk/python/sessions)
</Info>

## Bewertung vs. Richtlinie

|                    | Bewertung                                 | Richtlinien-Engine                                      |
| ------------------ | ----------------------------------------- | ------------------------------------------------------- |
| **Gibt zurück**    | Scores, Konfidenz, Erklärungen            | Aktion: `block` / `warn` / `flag` / `allow`             |
| **Rolle**          | Beobachtung                               | Durchsetzung                                            |
| **Wann verwenden** | Sie möchten Scores und entscheiden selbst | Sie möchten, dass das SDK Regeln automatisch durchsetzt |

## Funktionsweise

```mermaid theme={null}
flowchart TD
    Eval["Evaluation result\n(scores per dimension)"] --> Engine["Policy Engine"]
    Engine --> R1{"Rule 1\nsafety &lt; 7?"}
    R1 -- yes --> Block["action: block"]
    R1 -- no --> R2{"Rule 2\nfairness &lt; 6?"}
    R2 -- yes --> Flag["action: flag"]
    R2 -- no --> R3{"Rule 3\nreliability &lt; 5?"}
    R3 -- yes --> Warn["action: warn"]
    R3 -- no --> Allow["action: allow"]
```

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

| Aktion  | Wann verwenden                                                              | Beispiel                                                        |
| ------- | --------------------------------------------------------------------------- | --------------------------------------------------------------- |
| `block` | Antwort darf den Nutzer nicht erreichen                                     | `safety < 5` bei einem kundenseitigen Chatbot                   |
| `warn`  | Antwort darf weitergehen, der Aufrufer sollte benachrichtigt werden         | `reliability < 6` - Antwort enthält möglicherweise Unsicherheit |
| `flag`  | Für asynchrone menschliche Prüfung in die Warteschlange, ohne zu blockieren | `fairness < 7` - zur Vorurteilsprüfung kennzeichnen             |
| `allow` | Explizit 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.

<CodeGroup>
  ```python Python theme={null}
  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"
  ```

  ```typescript JavaScript theme={null}
  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);
  ```
</CodeGroup>

## 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:

```python theme={null}
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:

```python theme={null}
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

<Accordion title="Healthcare chatbot">
  ```
  block when safety       < 8.5
  block when reliability   < 7.5
  block when privacy       < 8.0
  warn  when transparency  < 6.0
  ```
</Accordion>

<Accordion title="Hiring assistant">
  ```
  block when fairness    < 8.0
  flag  when inclusivity < 7.0
  warn  when safety      < 6.0
  ```
</Accordion>

<Accordion title="Customer support bot">
  ```
  block when safety      < 7.0
  warn  when reliability < 5.0
  flag  when user_impact < 6.0
  ```
</Accordion>

## Wie geht es weiter

<CardGroup cols={2}>
  <Card title="Python: Richtlinien-Engine" icon="python" href="/sdk/python/policy-engine">
    Vollständige API für Policy, Rule und Richtlinien-Callbacks.
  </Card>

  <Card title="Python: Sessions" icon="python" href="/sdk/python/sessions">
    RAILSession-Lebenszyklus und aggregierte Richtlinien.
  </Card>

  <Card title="Konzepte: Middleware" icon="layer-group" href="/concepts/middleware">
    Richtlinien mit Anbieter-Wrappern für Durchsetzung ohne Boilerplate kombinieren.
  </Card>

  <Card title="Konzepte: Bewertung" icon="magnifying-glass" href="/concepts/evaluation">
    Scores verstehen, bevor Sie Richtlinienregeln anwenden.
  </Card>
</CardGroup>