Python: Middleware - RAIL Score

Concept: Middleware | Policy: Policy Engine

RAILMiddleware wraps any async function that generates text — your own model call, a provider SDK, whatever — and runs the full pipeline around it: an optional pre-hook, an optional input safety gate, the generation call itself, RAIL evaluation, policy enforcement, and an optional post-hook. It’s the general-purpose version of what the provider wrappers in Integrations do for OpenAI/Anthropic/Gemini specifically.

import asyncio
from rail_score_sdk import RAILMiddleware, Policy

async def my_model_call(messages, **kwargs):
    # Your generation call here — must accept `messages` and return a string
    return "The generated response."

async def main():
    mw = RAILMiddleware(
        api_key="YOUR_RAIL_API_KEY",
        generate_fn=my_model_call,
        threshold=7.0,
        policy=Policy.BLOCK,
        eval_input=True,
        input_threshold=5.0,
    )

    result = await mw.run(
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Explain quantum computing."},
        ]
    )
    print(f"Score: {result.score}, Met threshold: {result.threshold_met}")
    print(f"Content: {result.content}")

asyncio.run(main())

mw = RAILMiddleware(
    api_key="YOUR_RAIL_API_KEY",
    generate_fn=my_model_call,
    # policy defaults to Policy.LOG_ONLY — every response is scored, never blocked
)

result = await mw.run(messages=[...])
print(result.score)          # Always present
print(result.threshold_met)  # score >= threshold (threshold defaults to 7.0)

mw = RAILMiddleware(
    api_key="YOUR_RAIL_API_KEY",
    generate_fn=my_model_call,
    threshold=7.0,
    policy=Policy.REGENERATE,
)

result = await mw.run(messages=[...])
print(result.content)           # Best content — original or regenerated
print(result.was_regenerated)   # True if it didn't pass on the first try

Parameters

Parameter	Type	Default	Notes
`api_key`	`str`	—	Required.
`generate_fn`	async callable	—	Takes `messages=` (and any extra kwargs you pass to `run()`), returns the generated text as `str`.
`threshold`	`float`	`7.0`	Minimum acceptable score.
`policy`	`Policy \| str`	`Policy.LOG_ONLY`	See Policy Engine. `CUSTOM` is not currently supported here — use `RAILSession` or a standalone `PolicyEngine` for a custom callback.
`mode`	`str`	`"basic"`	`"basic"` or `"deep"`.
`domain`, `usecase`	`str`	`"general"`	Passed to each `/eval` call.
`eval_input`	`bool`	`False`	Also score the last user message before generating a response — see below.
`input_threshold`	`float`	`5.0`	Threshold for the input check. Raises `RAILBlockedError` if the input fails, regardless of `policy`.
`pre_hook`	async callable	`None`	`(messages) -> messages \| None`. Runs before generation; return a modified message list, or `None` to leave it unchanged.
`post_hook`	async callable	`None`	`(content, result) -> None`. Runs after policy enforcement, awaited inline.
`dpdp`	`dict`	`None`	Enables DPDP scanning of both the input and the generated output.

eval_input is a safety gate, not a quality gate: it always raises RAILBlockedError on a failing input score, independent of whatever policy you configured for the output.

The result

run() returns the same EvalResult used across the SDK’s policy-aware calls — see Policy Engine: the result object for the full field list (content, score, threshold_met, was_regenerated, dpdp, and so on).

Credits follow the calls run() makes on your behalf — one evaluation, plus an optional input-check evaluation, plus a regeneration if policy=Policy.REGENERATE triggers one. See Credits.

​Parameters

​The result

Parameters

The result