Middleware

Le middleware est le pattern qui consiste à intercepter chaque réponse du modèle et à y attacher un score RAIL avant qu’elle n’atteigne le reste de votre application. Vous remplacez votre client de modèle par un wrapper RAIL. Le wrapper appelle le modèle, évalue la réponse et retourne à la fois le contenu et les scores dans un seul objet.

SDK Python : Référence des intégrations | API : Endpoint d’évaluation

Le problème que ça résout

Sans middleware, ajouter des vérifications d’IA responsable à chaque appel de modèle implique d’écrire du code d’évaluation partout où vous appelez le modèle, de dupliquer la logique, de risquer des lacunes de couverture et d’encombrer votre code applicatif :

# Eval code scattered everywhere
async def get_response(user_message):
    response = await openai_client.chat.completions.create(
        model="gpt-4o", messages=[{"role": "user", "content": user_message}]
    )
    content = response.choices[0].message.content

    # Must remember to eval in every function
    score = rail_client.eval(content=content, mode="basic")
    if score.rail_score.score < 7.0:
        raise ValueError("Response below quality threshold")

    return content

# Scoring is automatic - set up once, forget about it
from rail_score_sdk.integrations import RAILOpenAI

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="YOUR_RAIL_API_KEY",
    eval_mode="basic",
    threshold=7.0,
)

async def get_response(user_message):
    response = await client.chat(messages=[{"role": "user", "content": user_message}])
    return response.content  # .rail_score and .threshold_met are also available

Comment ça fonctionne

Lorsque vous appelez une méthode sur le wrapper RAIL, trois choses se passent de manière transparente :

Vos messages sont transmis à l’API du modèle sous-jacent comme un appel API normal.
La réponse du modèle est soumise à l’endpoint d’évaluation RAIL dans le mode que vous avez configuré.
Un objet de réponse enrichi est retourné, contenant le contenu original, le score RAIL, les scores par dimension et un booléen threshold_met, le tout en une seule valeur de retour.

Fournisseurs pris en charge

Wrapper	Encapsule	Python	JavaScript
`RAILOpenAI`	OpenAI chat completions	Oui	Oui
`RAILGemini`	Google Gemini	Oui	Oui
`RAILAnthropic`	Anthropic Claude	Oui	Oui
`RAILLangChain`	Tout modèle LangChain	Oui	—
Wrapper personnalisé	Tout modèle basé sur HTTP	Oui	Oui

Mode observation vs mode application

Observation seule
Application du seuil
Régénération automatique

Évaluez chaque réponse, sans jamais bloquer. Utilisez ce mode pour mesurer la qualité sans interrompre le flux de réponses.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    # No threshold — always returns response
)

response = await client.chat(messages=[...])
print(response.content)        # The model's response
print(response.rail_score)     # RAIL score (always present)
print(response.threshold_met)  # None — no threshold configured

Lève une ThresholdError lorsqu’une réponse ne respecte pas le seuil.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    threshold=7.0,
)

try:
    response = await client.chat(messages=[...])
    return response.content
except ThresholdError as e:
    # e.rail_score and e.failed_dimensions are available
    return fallback_response()

Déclenche automatiquement la régénération sécurisée lorsqu’une réponse est en dessous du seuil.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    threshold=7.0,
    on_fail="regenerate",
    max_iterations=3,
)

# Returns the best content — original or regenerated
response = await client.chat(messages=[...])
print(response.content)
print(response.iterations_taken)  # 1 if original passed

Écrire un middleware personnalisé

Si vous utilisez un fournisseur de modèle sans wrapper intégré, construisez votre propre middleware en utilisant l’appel eval() de base :

from rail_score_sdk import RailScoreClient

rail = RailScoreClient(api_key="...")

async def rail_middleware(model_call, messages, threshold=7.0):
    """Generic RAIL middleware for any async model call."""
    content = await model_call(messages)

    result = rail.eval(content=content, mode="basic")

    if result.rail_score.score < threshold:
        raise ValueError(
            f"Response scored {result.rail_score.score:.1f} — below threshold {threshold}. "
            f"Failed: {[d for d, s in result.dimension_scores.items() if s.score < threshold]}"
        )

    return content, result

# Use with any model:
content, score = await rail_middleware(my_model_call, messages, threshold=7.5)

Et ensuite

Concepts : Moteur de politiques

Des règles déclaratives pour agir sur les scores au sein d’une session.

Python : Intégrations

Documentation complète des wrappers de fournisseurs et options.

JavaScript : Fournisseurs

Wrappers TypeScript pour OpenAI, Gemini, Anthropic.

Python : SDK Middleware

RAILMiddleware - encapsulez n’importe quelle fonction de modèle.

Premiers pas

Concepts de base

Gouvernance

Vérifications spécialisées

Le problème que ça résout

Comment ça fonctionne

Fournisseurs pris en charge

Mode observation vs mode application

Écrire un middleware personnalisé

Et ensuite

Concepts : Moteur de politiques

Python : Intégrations

JavaScript : Fournisseurs

Python : SDK Middleware

​Le problème que ça résout

​Comment ça fonctionne

​Fournisseurs pris en charge

​Mode observation vs mode application

​Écrire un middleware personnalisé

​Et ensuite

Concepts : Moteur de politiques

Python : Intégrations

JavaScript : Fournisseurs

Python : SDK Middleware

Le problème que ça résout

Comment ça fonctionne

Fournisseurs pris en charge

Mode observation vs mode application

Écrire un middleware personnalisé

Et ensuite