Passer au contenu principal
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

​
Comment ça fonctionne

Lorsque vous appelez une méthode sur le wrapper RAIL, trois choses se passent de manière transparente :
  1. Vos messages sont transmis à l’API du modèle sous-jacent comme un appel API normal.
  2. La réponse du modèle est soumise à l’endpoint d’évaluation RAIL dans le mode que vous avez configuré.
  3. 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

WrapperEncapsulePythonJavaScript
RAILOpenAIOpenAI chat completionsOuiOui
RAILGeminiGoogle GeminiOuiOui
RAILAnthropicAnthropic ClaudeOuiOui
RAILLangChainTout modèle LangChainOui—
Wrapper personnaliséTout modèle basé sur HTTPOuiOui

​
Mode observation vs mode application

É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

​
É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.