मुख्य सामग्री पर जाएं
Middleware वह pattern है जिसमें हर AI response को intercept करके, उसके आपकी बाकी application तक पहुंचने से पहले उस पर एक RAIL score जोड़ा जाता है। आप अपने AI client को एक RAIL wrapper से बदल देते हैं। wrapper model को call करता है, response को evaluate करता है, और content व scores दोनों को एक ही object में लौटा देता है।
Python SDK: Integrations reference | API: Evaluation endpoint

​
यह किस समस्या को हल करता है

middleware के बिना, हर AI call में responsible-AI checks जोड़ने का मतलब है कि जहाँ-जहाँ आप model को call करते हैं वहाँ evaluation code लिखना, logic को बार-बार दोहराना, coverage में गैप का खतरा, और application code को भर देना: 
# 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

​
यह कैसे काम करता है

जब आप RAIL wrapper पर कोई method call करते हैं, तो तीन चीज़ें पर्दे के पीछे होती हैं:
  1. आपके messages एक सामान्य API call की तरह नीचे वाले model API को forward किए जाते हैं।
  2. model की response आपके configure किए गए mode में RAIL evaluation endpoint को भेजी जाती है।
  3. एक wrapped response object लौटता है जिसमें original content, RAIL score, per-dimension scores, और एक threshold_met boolean, सब एक ही return value में होते हैं।

​
Supported providers

WrapperWrapsPythonJavaScript
RAILOpenAIOpenAI chat completionsYesYes
RAILGeminiGoogle GeminiYesYes
RAILAnthropicAnthropic ClaudeYesYes
RAILLangChainAny LangChain modelYes—
Custom wrapperकिसी भी HTTP-based modelYesYes

​
Observe mode vs enforce mode

हर response को score करें, कभी block न करें। इसे तब use करें जब आप response flow में रुकावट डाले बिना quality मापना चाहते हैं।
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 LLM's response
print(response.rail_score)     # RAIL score (always present)
print(response.threshold_met)  # None — no threshold configured

​
अपना custom middleware लिखना

अगर आप किसी ऐसे model provider को use करते हैं जिसका built-in wrapper नहीं है, तो core eval() call का इस्तेमाल करके अपना middleware बनाएं: 
from rail_score_sdk import RailScoreClient

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

async def rail_middleware(llm_call, messages, threshold=7.0):
    """Generic RAIL middleware for any async LLM call."""
    content = await llm_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 LLM:
content, score = await rail_middleware(my_llm_call, messages, threshold=7.5)

​
आगे क्या

Concepts: Policy Engine

किसी session भर scores पर action लेने के लिए declarative rules।

Python: Integrations

पूरा provider wrapper documentation और options।

JavaScript: Providers

OpenAI, Gemini, Anthropic के लिए TypeScript wrappers।

Python: Middleware SDK

RAILMiddleware - किसी भी model function को wrap करें।