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

# Moteur de politiques

> Des règles déclaratives qui traduisent les scores RAIL en actions : bloquer, avertir, signaler ou autoriser.

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](/concepts/applications) 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`](/api-reference/config) ; chaque évaluation rapporte un [`policy_outcome`](/api-reference/evaluation).
* **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.

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

## Évaluation vs politique

|                      | Évaluation                                      | Moteur de politiques                                       |
| -------------------- | ----------------------------------------------- | ---------------------------------------------------------- |
| **Retourne**         | Scores, confiance, explications                 | Action : `block` / `warn` / `flag` / `allow`               |
| **Rôle**             | Observation                                     | Application                                                |
| **Quand l'utiliser** | Vous voulez les scores et décidez quoi en faire | Vous voulez que le SDK applique les règles automatiquement |

## Comment ça fonctionne

```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"]
```

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

| Action  | Quand l'utiliser                                                        | Exemple                                                       |
| ------- | ----------------------------------------------------------------------- | ------------------------------------------------------------- |
| `block` | La réponse ne doit pas atteindre l'utilisateur                          | `safety < 5` sur un chatbot orienté client                    |
| `warn`  | La réponse peut être transmise, l'appelant doit être notifié            | `reliability < 6` - la réponse peut contenir de l'incertitude |
| `flag`  | Mettre en file d'attente pour une revue humaine asynchrone sans bloquer | `fairness < 7` - signaler pour revue de biais                 |
| `allow` | Laisser 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.

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

## Politiques réutilisables

Définissez une politique une seule fois et attachez-la au client pour qu'elle s'applique automatiquement à chaque appel `eval()` :

```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."
```

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

```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)
```

## Exemples de politiques concrets

<Accordion title="Chatbot médical">
  ```
  block when safety       < 8.5
  block when reliability   < 7.5
  block when privacy       < 8.0
  warn  when transparency  < 6.0
  ```
</Accordion>

<Accordion title="Assistant de recrutement">
  ```
  block when fairness    < 8.0
  flag  when inclusivity < 7.0
  warn  when safety      < 6.0
  ```
</Accordion>

<Accordion title="Bot de support client">
  ```
  block when safety      < 7.0
  warn  when reliability < 5.0
  flag  when user_impact < 6.0
  ```
</Accordion>

## Et ensuite

<CardGroup cols={2}>
  <Card title="Python : Moteur de politiques" icon="python" href="/sdk/python/policy-engine">
    API complète pour Policy, Rule et les callbacks de politique.
  </Card>

  <Card title="Python : Sessions" icon="python" href="/sdk/python/sessions">
    Cycle de vie de RAILSession et politiques agrégées.
  </Card>

  <Card title="Concepts : Middleware" icon="layer-group" href="/concepts/middleware">
    Combinez les politiques avec les wrappers de fournisseurs pour une application sans boilerplate.
  </Card>

  <Card title="Concepts : Évaluation" icon="magnifying-glass" href="/concepts/evaluation">
    Comprendre les scores avant d'appliquer des règles de politique.
  </Card>
</CardGroup>